From 17b411e2ec3e21b43d2cc9dd5cd192478ebe151a Mon Sep 17 00:00:00 2001
From: the_fiddler <the_fiddler@ebc5dd9b-fb1d-0410-b6f8-d24c324e9604>
Date: Sun, 15 Oct 2006 20:28:57 +0000
Subject: [PATCH] Directory structure updates (more to come)

Updated OpenTK.OpenGL.Bind (0.7.7)

Split GL enums, core and extensions to different files. Extension support is missing for the time being.

Updated the framework implementation and namespace.
---
 OpenTK.sln                                    |     5 +-
 Source/Examples/OpenGL/GLSL/Lesson01/Cube.cs  |     9 +-
 .../OpenGL/GLSL/Lesson01/GLSL.Lesson01.csproj |    21 +-
 Source/Framework/Framework.cs                 |   182 +-
 Source/Framework/FrameworkImplementation.cs   |    19 +
 ...amework.csproj => OpenTK.Framework.csproj} |    18 +-
 Source/Framework/Properties/AssemblyInfo.cs   |     4 +-
 Source/Framework/WindowsImplementation.cs     |    85 +
 Source/Framework/X11Implementation.cs         |    53 +
 .../Bind/{ => Documentation}/changelog.txt    |    14 +-
 Source/OpenGL/Bind/Documentation/todo.txt     |     6 +
 Source/OpenGL/Bind/Main.cs                    |     8 +-
 Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj  |     5 +-
 Source/OpenGL/Bind/Properties/AssemblyInfo.cs |     4 +-
 Source/OpenGL/Bind/ReadSpecs.cs               |     2 +
 Source/OpenGL/Bind/Structures/Constant.cs     |     8 +-
 Source/OpenGL/Bind/Structures/Enum.cs         |     4 +
 Source/OpenGL/Bind/Structures/Function.cs     |     8 +
 Source/OpenGL/Bind/Structures/Parameter.cs    |    34 +-
 Source/OpenGL/Bind/TranslateSpecs.cs          |    57 +-
 Source/OpenGL/Bind/WriteSpecs.cs              |   330 +-
 Source/OpenGL/Bind/todo.txt                   |     5 -
 Source/OpenGL/OpenGL/Bindings/GL.cs           | 49686 +---------------
 Source/OpenGL/OpenGL/Bindings/GLEnums.cs      |  5231 ++
 Source/OpenGL/OpenGL/Bindings/GLExtensions.cs | 42776 +++++++++++++
 Source/OpenGL/OpenGL/Contexts/GLContext.cs    |     8 +-
 .../OpenGL/OpenGL/Contexts/WindowsContext.cs  |     3 +-
 .../OpenGL/Contexts/WindowsVistaContext.cs    |     3 +-
 Source/OpenGL/OpenGL/Contexts/X11Context.cs   |    59 +-
 Source/OpenGL/OpenGL/GL.cs                    |    33 +
 Source/OpenGL/OpenGL/Glu.cs                   |     2 +-
 Source/OpenGL/OpenGL/Glx.cs                   |    45 +-
 Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj     |    22 +-
 Source/Platform/X/XApi.cs                     |    24 +-
 Specifications/TypeMap.txt                    |   289 -
 changelog.txt                                 |    15 +
 todo.txt                                      |     7 +-
 37 files changed, 49922 insertions(+), 49162 deletions(-)
 create mode 100644 Source/Framework/FrameworkImplementation.cs
 rename Source/Framework/{Framework.csproj => OpenTK.Framework.csproj} (81%)
 create mode 100644 Source/Framework/WindowsImplementation.cs
 create mode 100644 Source/Framework/X11Implementation.cs
 rename Source/OpenGL/Bind/{ => Documentation}/changelog.txt (67%)
 create mode 100644 Source/OpenGL/Bind/Documentation/todo.txt
 delete mode 100644 Source/OpenGL/Bind/todo.txt
 create mode 100644 Source/OpenGL/OpenGL/Bindings/GLEnums.cs
 create mode 100644 Source/OpenGL/OpenGL/Bindings/GLExtensions.cs
 create mode 100644 Source/OpenGL/OpenGL/GL.cs
 delete mode 100644 Specifications/TypeMap.txt

diff --git a/OpenTK.sln b/OpenTK.sln
index 8fd3a12c..696cf0a3 100644
--- a/OpenTK.sln
+++ b/OpenTK.sln
@@ -23,7 +23,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Specifications", "Specifica
 		Specifications\glxenumext.spec = Specifications\glxenumext.spec
 		Specifications\glxext.spec = Specifications\glxext.spec
 		Specifications\try.spec = Specifications\try.spec
-		Specifications\TypeMap.txt = Specifications\TypeMap.txt
 		Specifications\wgl.spec = Specifications\wgl.spec
 		Specifications\wgl.tm = Specifications\wgl.tm
 		Specifications\wglenum.spec = Specifications\wglenum.spec
@@ -49,8 +48,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "OpenGL", "OpenGL", "{2F3FEA
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenTK.OpenGL", "Source\OpenGL\OpenGL\OpenTK.OpenGL.csproj", "{836876D1-0C8D-4240-BEE4-859D9D3D46CB}"
 	ProjectSection(ProjectDependencies) = postProject
-		{FDFA00B6-FA81-4658-86E1-F312EFB42E1C} = {FDFA00B6-FA81-4658-86E1-F312EFB42E1C}
 		{1EDDE592-3923-4898-9006-3D69579E1745} = {1EDDE592-3923-4898-9006-3D69579E1745}
+		{FDFA00B6-FA81-4658-86E1-F312EFB42E1C} = {FDFA00B6-FA81-4658-86E1-F312EFB42E1C}
 	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenTK.OpenGL.Bind", "Source\OpenGL\Bind\OpenTK.OpenGL.Bind.csproj", "{1EDDE592-3923-4898-9006-3D69579E1745}"
@@ -65,7 +64,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenTK.Platform.X", "Source
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Framework", "Framework", "{508EF114-8C2A-470D-89FE-5AC15B336B4C}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Framework", "Source\Framework\Framework.csproj", "{26B55626-4EAB-4CAE-82FE-93CD6564D9EA}"
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OpenTK.Framework", "Source\Framework\OpenTK.Framework.csproj", "{26B55626-4EAB-4CAE-82FE-93CD6564D9EA}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
diff --git a/Source/Examples/OpenGL/GLSL/Lesson01/Cube.cs b/Source/Examples/OpenGL/GLSL/Lesson01/Cube.cs
index f751e8cb..a485cda2 100644
--- a/Source/Examples/OpenGL/GLSL/Lesson01/Cube.cs
+++ b/Source/Examples/OpenGL/GLSL/Lesson01/Cube.cs
@@ -11,7 +11,7 @@ using OpenTK.OpenGL;
 
 namespace OpenTK.Examples.OpenGL.GLSL
 {
-    public partial class Cube : Framework
+    public partial class Cube : OpenTK.Frameworks.Framework
     {
         #region Shaders
         string[] vertex_shader_source =
@@ -88,6 +88,9 @@ namespace OpenTK.Examples.OpenGL.GLSL
         {
             base.OnResize(e);
 
+//            if (this.Context == null)
+//                return;
+            
             if (ClientSize.Height == 0)
                 ClientSize = new System.Drawing.Size(ClientSize.Width, 1);
 
@@ -126,7 +129,7 @@ namespace OpenTK.Examples.OpenGL.GLSL
             DrawCube();
 
             Context.SwapBuffers();
-            //this.Invalidate();
+            this.Invalidate();
         }
         #endregion
 
@@ -198,4 +201,4 @@ namespace OpenTK.Examples.OpenGL.GLSL
         }
         #endregion
     }
-}
\ No newline at end of file
+}
diff --git a/Source/Examples/OpenGL/GLSL/Lesson01/GLSL.Lesson01.csproj b/Source/Examples/OpenGL/GLSL/Lesson01/GLSL.Lesson01.csproj
index c80395de..9d317c27 100644
--- a/Source/Examples/OpenGL/GLSL/Lesson01/GLSL.Lesson01.csproj
+++ b/Source/Examples/OpenGL/GLSL/Lesson01/GLSL.Lesson01.csproj
@@ -5,16 +5,23 @@
     <ProductVersion>8.0.50727</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{46980D11-67FA-4B33-903F-BC9D8A4FE60F}</ProjectGuid>
-    <OutputType>Exe</OutputType>
+    <OutputType>WinExe</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>OpenTK.Examples.OpenGL.GLSL</RootNamespace>
     <AssemblyName>GLSL.Lesson01</AssemblyName>
-    <StartupObject>
-    </StartupObject>
+    <AllowUnsafeBlocks>False</AllowUnsafeBlocks>
+    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
+    <NoStdLib>False</NoStdLib>
+    <RegisterForComInterop>False</RegisterForComInterop>
+    <GenerateSerializationAssemblies>Auto</GenerateSerializationAssemblies>
+    <BaseAddress>4194304</BaseAddress>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <FileAlignment>4096</FileAlignment>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
+    <DebugType>Full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>..\..\..\..\..\Binaries\Debug\Examples\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
@@ -63,9 +70,9 @@
     </Compile>
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\..\..\Framework\Framework.csproj">
+    <ProjectReference Include="..\..\..\..\Framework\OpenTK.Framework.csproj">
       <Project>{26B55626-4EAB-4CAE-82FE-93CD6564D9EA}</Project>
-      <Name>Framework %28Projects\OpenTK\Framework\Framework%29</Name>
+      <Name>OpenTK.Framework</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\..\..\OpenGL\OpenGL\OpenTK.OpenGL.csproj">
       <Project>{836876D1-0C8D-4240-BEE4-859D9D3D46CB}</Project>
@@ -76,5 +83,5 @@
       <Name>OpenTK.Platform.Windows</Name>
     </ProjectReference>
   </ItemGroup>
-  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
 </Project>
\ No newline at end of file
diff --git a/Source/Framework/Framework.cs b/Source/Framework/Framework.cs
index 25e0bc38..509bb97f 100644
--- a/Source/Framework/Framework.cs
+++ b/Source/Framework/Framework.cs
@@ -15,40 +15,111 @@ using System.Runtime.InteropServices;
 using OpenTK.OpenGL.Platform;
 using OpenTK.OpenGL;
 
-namespace OpenTK
+namespace OpenTK.Frameworks
 {
-    public class Framework : Form, IDisposable
+    public partial class Framework : Form, IDisposable
     {
+        #region Public properties
+
         #region Context
+
         private GLContext _context;
 
         public GLContext Context
         {
             get { return _context; }
-            set { _context = value; }
+            protected set { _context = value; }
         }
+
         #endregion
 
-        delegate bool IsIdleDelegate();
-        IsIdleDelegate IsIdle;
+        #region Fullscreen property
+
+        private bool _fullscreen;
+
+        public bool Fullscreen
+        {
+            get { return _fullscreen; }
+            set { _fullscreen = Implementation.ToggleFullscreen(_fullscreen); }
+        }
+
+        #endregion
+
+        #region DesktopResolution property
+
+        private Size _desktop_resolution;
+
+        public Size DesktopResolution
+        {
+            get { return _desktop_resolution; }
+            protected set { _desktop_resolution = value; }
+        }
+
+        #endregion
+
+        #region DesktopRefreshRate property
+
+        private float _desktop_refresh_rate;
+
+        public float DesktopRefreshRate
+        {
+            get { return _desktop_refresh_rate; }
+            protected set { _desktop_refresh_rate = value; }
+        }
+
+        #endregion
+
+        #endregion
+
+        FrameworkImplementation Implementation;
 
         #region Constructors
 
         public Framework()
         {
-            Open(null, 640, 480, 8, 8, 8, 8, 16, 0, false);
+            Setup(null, 640, 480, 8, 8, 8, 8, 16, 0, false);
         }
 
         public Framework(string title, int width, int height, int red, int green, int blue, int alpha, int depth, int stencil, bool fullscreen)
         {
-            Open(title, width, height, red, green, blue, alpha, depth, stencil, fullscreen);
+            Setup(title, width, height, red, green, blue, alpha, depth, stencil, fullscreen);
         }
 
         #endregion
 
-        public void Open(string title, int width, int height, int red, int green, int blue, int alpha, int depth, int stencil, bool fullscreen)
+        public void Setup(string title, int width, int height, int red, int green, int blue, int alpha, int depth, int stencil, bool fullscreen)
         {
-            Application.Idle += new EventHandler(OnIdle);
+            // Set platform.
+            try
+            {
+                if (Environment.OSVersion.Platform == PlatformID.Win32NT || Environment.OSVersion.Platform == PlatformID.Win32Windows)
+                {
+                    Implementation = new WindowsImplementation(this);
+                }
+                else if (Environment.OSVersion.Platform == PlatformID.Unix)
+                {
+                    Implementation = new X11Implementation();
+                }
+                else
+                {
+                    throw new PlatformNotSupportedException("The platform on which you are trying to run this program is not currently supported. Sorry for the inconvenience.");
+                }
+            }
+            catch (Exception e)
+            {
+                MessageBox.Show(e.ToString());
+                throw e;
+            }
+
+            Implementation.Setup();
+            this.HandleCreated += new EventHandler(Implementation.OnHandleCreated);
+            
+            //Type xplatui = Type.GetType("System.Windows.Forms.XplatUIX11, System.Windows.Forms");
+            //if (xplatui != null)
+            //{
+            //    Context = GLContext.Create(this, 8, 8, 8, 8, 16, 0);
+            //    //Context.MakeCurrent();
+            //}
             
             Context = GLContext.Create(this, red, green, blue, alpha, depth, stencil);
             
@@ -60,85 +131,15 @@ namespace OpenTK
             //this.SetStyle(ControlStyles.ResizeRedraw, true);                  // Redraw On Resize
             this.SetStyle(ControlStyles.UserPaint, true);                       // We'll Handle Painting Ourselves
 
-            try
-            {
-                if (Environment.OSVersion.Platform == PlatformID.Win32NT ||
-                    Environment.OSVersion.Platform == PlatformID.Win32Windows)
-                {
-                    IsIdle = new IsIdleDelegate(WindowsIsIdle);
-                    WindowsOpen(title, width, height, red, green, blue, alpha, depth, stencil, fullscreen);
-                }
-                else if (Environment.OSVersion.Platform == PlatformID.Unix)
-                {
-                    IsIdle = new IsIdleDelegate(XIsIdle);
-                }
-                else
-                {
-                    throw new PlatformNotSupportedException("The platform on which you are trying to run this program is not currently supported. Sorry for the inconvenience.");
-                }
-            }
-            catch (Exception e)
-            {
-                MessageBox.Show(e.ToString());
-            }
-        }
-
-        #region Open functions
-
-        public void WindowsOpen(string title, int width, int height, int red, int green, int blue, int alpha, int depth, int stencil, bool fullscreen)
-        {
             if (title == null)
                 title = "OpenTK Windows application";
             this.Text = title;
 
-            if (fullscreen)
-            {
-                Api.DeviceMode ScreenSettings = new Api.DeviceMode();       // Device Mode
-                ScreenSettings.Size = (short)Marshal.SizeOf(ScreenSettings);    // Size Of The Devmode Structure
-                ScreenSettings.PelsWidth = width;                           // Selected Screen Width
-                ScreenSettings.PelsHeight = height;                         // Selected Screen Height
-                ScreenSettings.BitsPerPel = red + green + blue + alpha;     // Selected Bits Per Pixel
-                ScreenSettings.Fields = Api.Constants.DM_BITSPERPEL | Api.Constants.DM_PELSWIDTH | Api.Constants.DM_PELSHEIGHT;
-
-                // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
-                if (Api.ChangeDisplaySettings(ref ScreenSettings, Api.Constants.CDS_FULLSCREEN) == Api.Constants.DISP_CHANGE_SUCCESSFUL)
-                {
-                    this.FormBorderStyle = FormBorderStyle.None;
-                    this.StartPosition = FormStartPosition.Manual;
-                    this.Location = new System.Drawing.Point(0, 0);
-                    this.Region = new Region(new Rectangle(0, 0, width, height));
-                    this.Capture = true;
-                    this.SetTopLevel(true);
-                    Cursor.Hide();
-                }
-                else
-                {
-                    // Handle failure.
-                }
-            }
-
             this.Size = new Size(width, height);
+
+            Application.Idle += new EventHandler(OnIdle);
         }
 
-        public void XOpen(string title, int width, int height, int red, int green, int blue, int alpha, int depth, int stencil, bool fullscreen)
-        {
-            Context = GLContext.Create(this, red, green, blue, alpha, depth, stencil);
-
-            if (title == null)
-                title = "OpenTK X application";
-            this.Text = title;
-
-            this.Size = new Size(width, height);
-        }
-
-        #endregion
-
-        //override protected void WndProc(ref Message m)
-        //{
-        //    base.WndProc(ref m);
-        //    //OnPaint(null);
-        //}
-
         #region Event Handlers
 
         /// <summary>
@@ -146,9 +147,9 @@ namespace OpenTK
         /// </summary>
         /// <param name="sender">Not used.</param>
         /// <param name="e">Not used.</param>
-        private void OnIdle(object sender, EventArgs e)
+        protected void OnIdle(object sender, EventArgs args)
         {
-            while (IsIdle())
+            while (Implementation.IsIdle())
             {
                 if (ActiveForm != this)
                     Thread.Sleep(100);
@@ -156,21 +157,6 @@ namespace OpenTK
             }
         }
 
-        /// <summary>
-        /// Checks if there all pending messages have been processed.
-        /// </summary>
-        /// <returns>Returns true if there are no messages left, false otherwise.</returns>
-        private bool WindowsIsIdle()
-        {
-            Api.Message msg;
-            return !OpenTK.Platform.Windows.Api.PeekMessage(out msg, IntPtr.Zero, 0, 0, 0);
-        }
-
-        private bool XIsIdle()
-        {
-            throw new NotImplementedException("IsIdle handler not implemented yet!");
-        }
-
         #endregion
 
         #region IDisposable Members
diff --git a/Source/Framework/FrameworkImplementation.cs b/Source/Framework/FrameworkImplementation.cs
new file mode 100644
index 00000000..35ba90ca
--- /dev/null
+++ b/Source/Framework/FrameworkImplementation.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Drawing;
+
+namespace OpenTK.Frameworks
+{
+    public partial class Framework
+    {
+        internal abstract class FrameworkImplementation
+        {
+            abstract public void OnHandleCreated(object sender, EventArgs args);
+            abstract public bool IsIdle();
+            abstract public void Setup();
+            //abstract public void CloseWindow();
+            abstract public bool ToggleFullscreen(bool fullscreen);
+        }
+    }
+}
diff --git a/Source/Framework/Framework.csproj b/Source/Framework/OpenTK.Framework.csproj
similarity index 81%
rename from Source/Framework/Framework.csproj
rename to Source/Framework/OpenTK.Framework.csproj
index 494dca43..3ac5840e 100644
--- a/Source/Framework/Framework.csproj
+++ b/Source/Framework/OpenTK.Framework.csproj
@@ -7,8 +7,10 @@
     <ProjectGuid>{26B55626-4EAB-4CAE-82FE-93CD6564D9EA}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Framework</RootNamespace>
-    <AssemblyName>Framework</AssemblyName>
+    <RootNamespace>OpenTK</RootNamespace>
+    <AssemblyName>OpenTK.Framework</AssemblyName>
+    <StartupObject>
+    </StartupObject>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -38,7 +40,16 @@
     <Compile Include="Framework.cs">
       <SubType>Form</SubType>
     </Compile>
+    <Compile Include="FrameworkImplementation.cs">
+      <SubType>Form</SubType>
+    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="WindowsImplementation.cs">
+      <SubType>Form</SubType>
+    </Compile>
+    <Compile Include="X11Implementation.cs">
+      <SubType>Form</SubType>
+    </Compile>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\OpenGL\OpenGL\OpenTK.OpenGL.csproj">
@@ -54,6 +65,9 @@
       <Name>OpenTK.Platform.X</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Documentation\" />
+  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Source/Framework/Properties/AssemblyInfo.cs b/Source/Framework/Properties/AssemblyInfo.cs
index 764858c5..54d3ab13 100644
--- a/Source/Framework/Properties/AssemblyInfo.cs
+++ b/Source/Framework/Properties/AssemblyInfo.cs
@@ -31,5 +31,5 @@ using System.Runtime.InteropServices;
 //
 // You can specify all the values or you can default the Revision and Build Numbers 
 // by using the '*' as shown below:
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyVersion("0.3.1.0")]
+[assembly: AssemblyFileVersion("0.3.1.0")]
diff --git a/Source/Framework/WindowsImplementation.cs b/Source/Framework/WindowsImplementation.cs
new file mode 100644
index 00000000..818548b5
--- /dev/null
+++ b/Source/Framework/WindowsImplementation.cs
@@ -0,0 +1,85 @@
+#region License
+/* Copyright (c) 2006 Stephen Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Threading;
+using OpenTK.Platform.Windows;
+using System.Runtime.InteropServices;
+using OpenTK.OpenGL.Platform;
+using OpenTK.OpenGL;
+
+namespace OpenTK.Frameworks
+{
+    public partial class Framework
+    {
+        internal class WindowsImplementation : FrameworkImplementation
+        {
+            private Framework framework;
+
+            public WindowsImplementation(Framework f)
+            {
+                framework = f;
+                // Set desktop resolution, refresh rate, pixel depth
+            }
+
+            override public void OnHandleCreated(object sender, EventArgs args)
+            {
+                //throw new Exception("The method or operation is not implemented.");
+            }
+
+            /// <summary>
+            /// Checks if there all pending messages have been processed.
+            /// </summary>
+            /// <returns>Returns true if there are no messages left, false otherwise.</returns>
+            override public bool IsIdle()
+            {
+                Api.Message msg;
+                return !Api.PeekMessage(out msg, IntPtr.Zero, 0, 0, 0);
+            }
+
+            override public void Setup()
+            {
+            }
+
+            public override bool ToggleFullscreen(bool fullscreen)
+            {
+                if (fullscreen)
+                {
+                    Api.DeviceMode ScreenSettings = new Api.DeviceMode();       // Device Mode
+                    ScreenSettings.Size = (short)Marshal.SizeOf(ScreenSettings);    // Size Of The Devmode Structure
+                    ScreenSettings.PelsWidth = 640;// width;                           // Selected Screen Width
+                    ScreenSettings.PelsHeight = 480;// height;                         // Selected Screen Height
+                    ScreenSettings.BitsPerPel = 32;// red + green + blue + alpha;     // Selected Bits Per Pixel
+                    ScreenSettings.Fields = Api.Constants.DM_BITSPERPEL | Api.Constants.DM_PELSWIDTH | Api.Constants.DM_PELSHEIGHT;
+
+                    // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
+                    if (Api.ChangeDisplaySettings(ref ScreenSettings, Api.Constants.CDS_FULLSCREEN) == Api.Constants.DISP_CHANGE_SUCCESSFUL)
+                    {
+                        framework.FormBorderStyle = FormBorderStyle.None;
+                        framework.StartPosition = FormStartPosition.Manual;
+                        framework.Location = new System.Drawing.Point(0, 0);
+                        //this.Region = new Region(new Rectangle(0, 0, width, height));
+                        framework.Capture = true;
+                        framework.SetTopLevel(true);
+                        Cursor.Hide();
+
+                        return !fullscreen;
+                    }
+                    else
+                    {
+                        // Handle failure.
+                    }
+                }
+
+                return fullscreen;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Source/Framework/X11Implementation.cs b/Source/Framework/X11Implementation.cs
new file mode 100644
index 00000000..b2e8838c
--- /dev/null
+++ b/Source/Framework/X11Implementation.cs
@@ -0,0 +1,53 @@
+#region License
+/* Copyright (c) 2006 Stephen Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Threading;
+using OpenTK.Platform.X;
+using System.Runtime.InteropServices;
+using OpenTK.OpenGL.Platform;
+using OpenTK.OpenGL;
+
+namespace OpenTK.Frameworks
+{
+    public partial class Framework
+    {
+        internal class X11Implementation : FrameworkImplementation
+        {
+            private IntPtr display;
+            public GLContext Context;
+
+            public override void OnHandleCreated(object sender, EventArgs args)
+            {
+
+            }
+
+            public override bool IsIdle()
+            {
+                return Api.Pending(display) == 0 ? true : false;
+            }
+
+            public override void Setup()
+            {
+                //    			Type xplatui = Type.GetType("System.Windows.Forms.XplatUIX11, System.Windows.Forms");
+                //    			if (xplatui != null)
+                //    			{
+                //                    display = (IntPtr)xplatui.GetField("DisplayHandle",
+                //                                                       System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic).GetValue(null);
+                //              }
+            }
+
+            public override bool ToggleFullscreen(bool fullscreen)
+            {
+                throw new Exception("The method or operation is not implemented.");
+            }
+        }
+    }
+}
diff --git a/Source/OpenGL/Bind/changelog.txt b/Source/OpenGL/Bind/Documentation/changelog.txt
similarity index 67%
rename from Source/OpenGL/Bind/changelog.txt
rename to Source/OpenGL/Bind/Documentation/changelog.txt
index de037f1e..6520801d 100644
--- a/Source/OpenGL/Bind/changelog.txt
+++ b/Source/OpenGL/Bind/Documentation/changelog.txt
@@ -1,8 +1,18 @@
-OpenTK.OpenGL.Bind 0.7.6
+OpenTK.OpenGL.Bind 0.7.7
+
+0.7.6 -> 0.7.7
++ Several bugfixes regarding bugs from the latest (0.7.6) code synchronisation between Tao.GlBindGen and OpenTK.OpenGL.Bind
++ Split the Enums, Core OpenGL and Extension OpenGL functions into different files. This speeds up the Visual Studio IDE a lot.
++ The Extension functions have been removed from the OpenTK.OpenGL.GL class. They will be added back on a later version, probably as OpenTK.OpenGL.GL.Extensions. No need to clatter up the code API with thousands of mostly useless extensions.
+	+ Applications load much faster now.
++ Killed the Context class generation. It added a lot of complexity for little gain (what, cleaner OOP internal structure? Oh, please!) This move frees up the Context classes which can now be updated without dragging around several thousand function initialisations.
+	+ OpenTK.OpenGL.GL is self-contained now. Delegates are initialised statically, calling the platform specific *GetAddress functions where needed (they are contained in the GL class, too - but not auto-generated).
++ Revamped the WriteSpecs class. Its methods are now completely modular (enum, core and extension writers have been split).
+	+ This still needs some refactoring to reduce code copy-paste and allow for future wgl / glx binding generation.
 
 
 0.7.5.2 -> 0.7.6
-+ Added NeedWrapper and WrapperType properties to each parameter (needed for more fince grained control on wrapper generation).
++ Added NeedWrapper and WrapperType properties to each parameter (needed for more fine grained control on wrapper generation).
 + Added Function, Parameter, ParameterCollection (deep) copy constructors. This allows simpler code in many places (since we can now create new Functions without fear of affecting the old ones, for example).
 + Merged the ParameterCollection.cs with Parameter.cs
 + Added the FunctionBody class which contains the contents of a function as a list of strings. It is mainly intended for wrappers (allows cleaner code, too).
diff --git a/Source/OpenGL/Bind/Documentation/todo.txt b/Source/OpenGL/Bind/Documentation/todo.txt
new file mode 100644
index 00000000..d97d371b
--- /dev/null
+++ b/Source/OpenGL/Bind/Documentation/todo.txt
@@ -0,0 +1,6 @@
+OpenTK.OpenGL.Bind 0.7.7 todos:
+
++ Add the binding generation for extensions.
++ Clean up the reader.
++ Add more settings to Settings.cs (the name of the files to read).
++ Comment the code.
\ No newline at end of file
diff --git a/Source/OpenGL/Bind/Main.cs b/Source/OpenGL/Bind/Main.cs
index 12c0d112..2ff81394 100644
--- a/Source/OpenGL/Bind/Main.cs
+++ b/Source/OpenGL/Bind/Main.cs
@@ -96,10 +96,10 @@ namespace OpenTK.OpenGL.Bind
 
                 SpecWriter.WriteSpecs(Settings.OutputPath, Settings.GLClass, functions, wrappers, enums);
 
-                ContextWriter.WriteMainContext(Settings.OutputPath, "GLContext", Settings.GLClass, functions);
-                ContextWriter.WriteDerivedContext(Settings.OutputPath, "WindowsContext", Settings.GLClass, functions, "1.0", "1.1");
-                ContextWriter.WriteDerivedContext(Settings.OutputPath, "WindowsVistaContext", Settings.GLClass, functions, "1.0", "1.1", "1.2", "1.3", "1.4");
-                ContextWriter.WriteDerivedContext(Settings.OutputPath, "X11Context", Settings.GLClass, functions, "1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "2.0");
+                //ContextWriter.WriteMainContext(Settings.OutputPath, "GLContext", Settings.GLClass, functions);
+                //ContextWriter.WriteDerivedContext(Settings.OutputPath, "WindowsContext", Settings.GLClass, functions, "1.0", "1.1");
+                //ContextWriter.WriteDerivedContext(Settings.OutputPath, "WindowsVistaContext", Settings.GLClass, functions, "1.0", "1.1", "1.2", "1.3", "1.4");
+                //ContextWriter.WriteDerivedContext(Settings.OutputPath, "X11Context", Settings.GLClass, functions, "1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "2.0");
 
                 // GLX binding generation.
                 //Translation.GLXTypes = SpecReader.ReadTypeMap("glx.tm"); // Works semi-ok.
diff --git a/Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj b/Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj
index 840f5acf..9bc19bae 100644
--- a/Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj
+++ b/Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj
@@ -54,12 +54,11 @@
     <Compile Include="Structures\Function.cs" />
     <Compile Include="Structures\Parameter.cs" />
     <Compile Include="TranslateSpecs.cs" />
-    <Compile Include="WriteContexts.cs" />
     <Compile Include="WriteSpecs.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Content Include="changelog.txt" />
-    <Content Include="todo.txt" />
+    <Content Include="Documentation\changelog.txt" />
+    <Content Include="Documentation\todo.txt" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
 </Project>
\ No newline at end of file
diff --git a/Source/OpenGL/Bind/Properties/AssemblyInfo.cs b/Source/OpenGL/Bind/Properties/AssemblyInfo.cs
index a66e866a..563de4ba 100644
--- a/Source/OpenGL/Bind/Properties/AssemblyInfo.cs
+++ b/Source/OpenGL/Bind/Properties/AssemblyInfo.cs
@@ -29,5 +29,5 @@ using System.Runtime.InteropServices;
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("0.7.6.0")]
-[assembly: AssemblyFileVersion("0.7.6.0")]
+[assembly: AssemblyVersion("0.7.7.0")]
+[assembly: AssemblyFileVersion("0.7.7.0")]
diff --git a/Source/OpenGL/Bind/ReadSpecs.cs b/Source/OpenGL/Bind/ReadSpecs.cs
index ee711c43..cb05487b 100644
--- a/Source/OpenGL/Bind/ReadSpecs.cs
+++ b/Source/OpenGL/Bind/ReadSpecs.cs
@@ -128,6 +128,7 @@ namespace OpenTK.OpenGL.Bind
         #endregion
 
         #region Read enum specs
+
         public static Hashtable ReadEnumSpecs(string file)
         {
             Hashtable enums = new Hashtable();
@@ -235,6 +236,7 @@ namespace OpenTK.OpenGL.Bind
 
             return enums;
         }
+
         #endregion
 
         #region Read type map
diff --git a/Source/OpenGL/Bind/Structures/Constant.cs b/Source/OpenGL/Bind/Structures/Constant.cs
index f91b36ea..2a67d3d2 100644
--- a/Source/OpenGL/Bind/Structures/Constant.cs
+++ b/Source/OpenGL/Bind/Structures/Constant.cs
@@ -9,6 +9,8 @@ using System.Text;
 
 namespace OpenTK.OpenGL.Bind
 {
+    #region Constant class
+
     /// <summary>
     /// Represents an opengl constant in C# format. Both the constant name and value
     /// can be retrieved or set. The value can be either a number, another constant
@@ -76,18 +78,20 @@ namespace OpenTK.OpenGL.Bind
 
         #endregion
 
-        #region Helper functions
+        #region public string ToString()
 
         /// <summary>
         /// Returns a string that represents the full constant declaration without decorations
         /// (eg const uint GL_XXX_YYY = 0xDEADBEEF).
         /// </summary>
         /// <returns></returns>
-        new public string ToString()
+        override public string ToString()
         {
             return Name + " = " + Value;
         }
 
         #endregion
     }
+
+    #endregion
 }
diff --git a/Source/OpenGL/Bind/Structures/Enum.cs b/Source/OpenGL/Bind/Structures/Enum.cs
index dc426cfc..d74908b7 100644
--- a/Source/OpenGL/Bind/Structures/Enum.cs
+++ b/Source/OpenGL/Bind/Structures/Enum.cs
@@ -9,6 +9,8 @@ using System.Text;
 
 namespace OpenTK.OpenGL.Bind
 {
+    #region class Enum
+
     public class Enum
     {
         string _name;
@@ -42,4 +44,6 @@ namespace OpenTK.OpenGL.Bind
             return sb.ToString();
         }
     }
+
+    #endregion
 }
diff --git a/Source/OpenGL/Bind/Structures/Function.cs b/Source/OpenGL/Bind/Structures/Function.cs
index 73ac85ba..52974ad9 100644
--- a/Source/OpenGL/Bind/Structures/Function.cs
+++ b/Source/OpenGL/Bind/Structures/Function.cs
@@ -9,6 +9,8 @@ using System.Text;
 
 namespace OpenTK.OpenGL.Bind
 {
+    #region class Function
+
     /// <summary>
     /// Represents an opengl function.
     /// The return value, function name, function parameters and opengl version can be retrieved or set.
@@ -219,6 +221,10 @@ namespace OpenTK.OpenGL.Bind
 
     }
 
+    #endregion
+
+    #region class FunctionBody : List<string>
+
     public class FunctionBody : List<string>
     {
         public FunctionBody()
@@ -255,4 +261,6 @@ namespace OpenTK.OpenGL.Bind
             return sb.ToString();
         }
     }
+
+    #endregion
 }
diff --git a/Source/OpenGL/Bind/Structures/Parameter.cs b/Source/OpenGL/Bind/Structures/Parameter.cs
index 25343943..b8720a62 100644
--- a/Source/OpenGL/Bind/Structures/Parameter.cs
+++ b/Source/OpenGL/Bind/Structures/Parameter.cs
@@ -10,6 +10,8 @@ using System.Runtime.InteropServices;
 
 namespace OpenTK.OpenGL.Bind
 {
+    #region Parameter class
+
     /// <summary>
     /// Represents a single parameter of an opengl function.
     /// </summary>
@@ -24,6 +26,10 @@ namespace OpenTK.OpenGL.Bind
         {
         }
 
+        /// <summary>
+        /// Creates a new parameter from the parameters passed (deep copy).
+        /// </summary>
+        /// <param name="p">The parameter to copy from.</param>
         public Parameter(Parameter p)
         {
             if (p == null)
@@ -190,14 +196,7 @@ namespace OpenTK.OpenGL.Bind
             //if (Flow == FlowDirection.Out && !Array && !(Type == "IntPtr"))
             //    sb.Append("out ");
 
-            //if (Unchecked)
-            //    sb.Append("unchecked(");
-
             sb.Append(Type);
-
-            //if (Unchecked)
-            //    sb.Append(")");
-
             if (Array)
                 sb.Append("[]");
 
@@ -209,8 +208,13 @@ namespace OpenTK.OpenGL.Bind
         #endregion
     }
 
+    #endregion
+
     #region ParameterCollection class
 
+    /// <summary>
+    /// Holds the parameter list of an opengl function.
+    /// </summary>
     public class ParameterCollection : List<Parameter>
     {
         #region Constructors
@@ -229,6 +233,12 @@ namespace OpenTK.OpenGL.Bind
 
         #endregion
 
+        #region override public string ToString()
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns>The parameter list of an opengl function in the form ( [parameters] )</returns>
         override public string ToString()
         {
             StringBuilder sb = new StringBuilder();
@@ -256,6 +266,10 @@ namespace OpenTK.OpenGL.Bind
             return false;
         }
 
+        #endregion
+
+        #region public ParameterCollection ReplaceAll(Parameter, Parameter)
+
         /// <summary>
         /// Replaces all parameters that match the old_param with the new_param.
         /// </summary>
@@ -291,6 +305,10 @@ namespace OpenTK.OpenGL.Bind
             return pc;
         }
 
+        #endregion
+
+        #region public ParameterCollection Replace(Parameter, Parameter)
+
         /// <summary>
         /// Replaces the first parameter that matches old_param with new_param.
         /// </summary>
@@ -326,6 +344,8 @@ namespace OpenTK.OpenGL.Bind
 
             return pc;
         }
+
+        #endregion
     }
 
     #endregion
diff --git a/Source/OpenGL/Bind/TranslateSpecs.cs b/Source/OpenGL/Bind/TranslateSpecs.cs
index adb1eaba..41498bb0 100644
--- a/Source/OpenGL/Bind/TranslateSpecs.cs
+++ b/Source/OpenGL/Bind/TranslateSpecs.cs
@@ -11,19 +11,17 @@ using System.Collections;
 namespace OpenTK.OpenGL.Bind
 {
     #region WrapperTypes enum
+
     public enum WrapperTypes
     {
         None,
-        VoidPointerIn,
-        VoidPointerOut,
-        VoidPointer,
-        ArrayOut,
-        ArrayIn,
+        VoidArray,
         Array,
-        UShortMaskParameter,
+        UncheckedParameter,
         ReturnsString,
         ReturnsVoidPointer,
     }
+
     #endregion
 
     static class Translation
@@ -222,23 +220,22 @@ namespace OpenTK.OpenGL.Bind
         {
             string s;
 
-            // Map parameters.
-            foreach (Parameter p in f.Parameters)
+            foreach (Parameter p in f.Parameters)   // Translate each parameter of the function, and check for needed wrappers.
             {
-                #region Default name translation
+                #region Translate parameter name
 
                 if (parameter_names.TryGetValue(p.Name, out s))
                     p.Name = s;
 
                 #endregion
 
-                #region Default type translation
+                #region Translate parameter type
 
-                if (p.Type.Contains("Boolean"))
-                {
-                    p.Type = "GLboolean";
-                }
-                else if (enums.ContainsKey(p.Type))
+                //if (p.Type.Contains("Boolean"))
+                //{
+                //    p.Type = "GLboolean";
+                //}
+                if (enums.ContainsKey(p.Type))
                 {
                     p.Type = "Enums." + p.Type;
                 }
@@ -250,51 +247,47 @@ namespace OpenTK.OpenGL.Bind
                 else if (GLTypes.TryGetValue(p.Type, out s))
                     p.Type = s;
 
+
                 #endregion
 
-                #region Wrapper translations
+                #region Check for needed wrappers
 
-                if (p.Type.Contains("ushort") && f.Name.Contains("LineStipple"))
+                if (p.Type.Contains("ushort") && f.Name.Contains("LineStipple"))    // glLineStipple needs wrapper to allow for unchecked mask values.
                 {
-                    //f.NeedsWrapper = true;
-                    //f.WrapperType = WrapperTypes.UShortMaskParameter;
                     p.NeedsWrapper = true;
-                    p.WrapperType = WrapperTypes.UShortMaskParameter;
+                    p.WrapperType = WrapperTypes.UncheckedParameter;
                     p.Unchecked = true;
                 }
-                else if (p.Array && p.Type.Contains("string"))
+                else if (p.Array && p.Type.Contains("string"))  // string parameters do not need special wrappers.
                 {
                     p.NeedsWrapper = false;
                     p.WrapperType = WrapperTypes.None;
                 }
-                else if (p.Array && p.Type.Contains("char"))
+                else if (p.Array && p.Type.Contains("char"))    // GLchar[] parameters should become (in) string or (out) StringBuilder
                 {
                     if (p.Flow == Parameter.FlowDirection.Out)
                         p.Type = "StringBuilder";
-                    else 
+                    else
                         p.Type = "string";
                     p.Array = false;
-                    //f.Nee
                 }
-                else if (p.Array)
+                else if (p.Array)                               // All other array parameters need wrappers (around IntPtr).
                 {
-                    //f.NeedsWrapper = true;
                     p.NeedsWrapper = true;
 
                     if (p.Type.Contains("void"))
-                        p.WrapperType = WrapperTypes.VoidPointer;
+                        p.WrapperType = WrapperTypes.VoidArray;
                     else
                         p.WrapperType = WrapperTypes.Array;
 
                     p.Type = "IntPtr";
-                    p.Array = false;
-                    p.Flow = Parameter.FlowDirection.Undefined;
+                    p.Array = false;    // We do not want an array of IntPtrs (IntPtr[]) - it is the IntPtr that points to the array.
+                    p.Flow = Parameter.FlowDirection.Undefined; // The same wrapper works for either in or out parameters.
                 }
 
-                if (p.NeedsWrapper)
+                if (p.NeedsWrapper)     // If there is at least 1 parameter that needs wrappers, mark the funcction for wrapping.
                 {
                     f.NeedsWrapper = true;
-                    //f.WrapperType = WrapperTypes.Array;
                     f.WrapperType = p.WrapperType;
                 }
 
@@ -315,7 +308,7 @@ namespace OpenTK.OpenGL.Bind
             {
                 if (f.NeedsWrapper)
                 {
-                    if (f.WrapperType == WrapperTypes.UShortMaskParameter)
+                    if (f.WrapperType == WrapperTypes.UncheckedParameter)
                     {
                         w = new Function(f);
                         w.Name = w.Name.TrimEnd('_');
diff --git a/Source/OpenGL/Bind/WriteSpecs.cs b/Source/OpenGL/Bind/WriteSpecs.cs
index beafea73..27789510 100644
--- a/Source/OpenGL/Bind/WriteSpecs.cs
+++ b/Source/OpenGL/Bind/WriteSpecs.cs
@@ -14,38 +14,48 @@ namespace OpenTK.OpenGL.Bind
 {
     static partial class SpecWriter
     {
-        #region WriteSpecs
+        #region Write specs
+
         public static void WriteSpecs(string output_path, string class_name, List<Function> functions, List<Function> wrappers, Hashtable enums)
         {
-            string filename = Path.Combine(output_path, class_name + ".cs");
+            WriteEnumSpecs(output_path, class_name, enums);
+            WriteCoreFunctionSpecs(output_path, class_name, functions, wrappers);
+            WriteExtensionFunctionSpecs(output_path, class_name, functions, wrappers);
+        }
 
-            if (!Directory.Exists(Settings.OutputPath))
-                Directory.CreateDirectory(Settings.OutputPath);
+        #endregion
+
+        #region Write extension function specs
+
+        private static void WriteExtensionFunctionSpecs(string output_path, string class_name, List<Function> functions, List<Function> wrappers)
+        {
+            string filename = Path.Combine(output_path, class_name + "Extensions.cs");
+
+            if (!Directory.Exists(output_path))
+                Directory.CreateDirectory(output_path);
 
             StreamWriter sw = new StreamWriter(filename, false);
 
             Console.WriteLine("Writing {0} class to {1}", class_name, filename);
 
             WriteLicense(sw);
+            WriteUsingDirectives(sw);
 
-            sw.WriteLine("using System;");
-            sw.WriteLine("using System.Runtime.InteropServices;");
-            sw.WriteLine("using System.Text;");
-            sw.WriteLine();
             sw.WriteLine("namespace {0}", Settings.OutputNamespace);
             sw.WriteLine("{");
 
             WriteTypes(sw);
-            WriteEnums(sw, enums);
 
-            sw.WriteLine("    public static partial class {0}", class_name);
+            sw.WriteLine("    static public partial class {0}", class_name);
             sw.WriteLine("    {");
+            sw.WriteLine("        static public class Extensions");
+            sw.WriteLine("        {");
 
-            WriteFunctionSignatures(sw, functions);
-            WriteDllImports(sw, functions);
-            WriteFunctions(sw, functions);
-            WriteWrappers(sw, wrappers);
+            WriteExtensionFunctionSignatures(sw, functions);
+            WriteExtensionFunctions(sw, functions);
+            WriteExtensionWrappers(sw, wrappers);
 
+            sw.WriteLine("        }");
             sw.WriteLine("    }");
             sw.WriteLine("}");
             sw.WriteLine();
@@ -53,17 +63,108 @@ namespace OpenTK.OpenGL.Bind
             sw.Flush();
             sw.Close();
         }
+
         #endregion
 
-        #region WriteLicense
+        #region Write core function specs
+
+        private static void WriteCoreFunctionSpecs(string output_path, string class_name, List<Function> functions, List<Function> wrappers)
+        {
+            string filename = Path.Combine(output_path, class_name + ".cs");
+
+            if (!Directory.Exists(output_path))
+                Directory.CreateDirectory(output_path);
+
+            StreamWriter sw = new StreamWriter(filename, false);
+
+            Console.WriteLine("Writing {0} class to {1}", class_name, filename);
+
+            WriteLicense(sw);
+            WriteUsingDirectives(sw);
+
+            WriteTypes(sw);
+
+            sw.WriteLine("namespace {0}", Settings.OutputNamespace);
+            sw.WriteLine("{");
+            sw.WriteLine("    static public partial class {0}", class_name);
+            sw.WriteLine("    {");
+
+            sw.WriteLine("        static public void Init()");
+            sw.WriteLine("        {");
+            sw.WriteLine("        }");
+
+            WriteCoreFunctionSignatures(sw, functions);
+            WriteDllImports(sw, functions);
+            WriteCoreFunctions(sw, functions);
+            WriteCoreWrappers(sw, wrappers);
+            WriteCoreConstructor(sw, class_name, functions);
+
+            sw.WriteLine("    }");
+
+            sw.WriteLine("}");
+            sw.WriteLine();
+
+            sw.Flush();
+            sw.Close();
+        }
+
+        #endregion
+
+        #region Write enum specs
+
+        private static void WriteEnumSpecs(string output_path, string class_name, Hashtable enums)
+        {
+            string filename = Path.Combine(output_path, class_name + "Enums.cs");
+
+            if (!Directory.Exists(output_path))
+                Directory.CreateDirectory(output_path);
+
+            StreamWriter sw = new StreamWriter(filename, false);
+
+            Console.WriteLine("Writing {0} class to {1}", class_name, filename);
+
+            WriteLicense(sw);
+            WriteUsingDirectives(sw);
+
+            sw.WriteLine("namespace {0}", Settings.OutputNamespace);
+            sw.WriteLine("{");
+
+            WriteTypes(sw);
+            WriteEnums(sw, enums);
+
+            sw.WriteLine("}");
+            sw.WriteLine();
+
+            sw.Flush();
+            sw.Close();
+        }
+
+        #endregion
+
+        #region Write license
+
         public static void WriteLicense(StreamWriter sw)
         {
             sw.WriteLine("#region License");
-            sw.WriteLine("//Copyright (c) 2006 Stephen Apostolopoulos");
+            sw.WriteLine("//THIS FILE IS AUTOMATICALLY GENERATED");
+            sw.WriteLine("//DO NOT EDIT BY HAND!!");
             sw.WriteLine("//See license.txt for license info");
             sw.WriteLine("#endregion");
             sw.WriteLine();
         }
+
+        #endregion
+
+        #region Write using directivers
+
+        private static void WriteUsingDirectives(StreamWriter sw)
+        {
+            sw.WriteLine("using System;");
+            sw.WriteLine("using System.Runtime.InteropServices;");
+            sw.WriteLine("using System.Text;");
+            sw.WriteLine();
+        }
+
         #endregion
 
         #region Write types
@@ -84,23 +185,13 @@ namespace OpenTK.OpenGL.Bind
         #endregion
 
         #region Write enums
+
         private static void WriteEnums(StreamWriter sw, Hashtable enums)
         {
             sw.WriteLine("    #region Enums");
             sw.WriteLine("    public struct Enums");
             sw.WriteLine("    {");
 
-            #region Missing constants
-
-            sw.WriteLine("        #region Missing Constants");
-            sw.WriteLine();
-
-            sw.WriteLine();
-            sw.WriteLine("        #endregion");
-            sw.WriteLine();
-
-            #endregion
-
             foreach (Enum e in enums.Values)
             {
                 sw.WriteLine(e.ToString());
@@ -110,10 +201,12 @@ namespace OpenTK.OpenGL.Bind
             sw.WriteLine("    #endregion");
             sw.WriteLine();
         }
+
         #endregion
 
-        #region Write function signatures
-        private static void WriteFunctionSignatures(StreamWriter sw, List<Function> functions)
+        #region Write core function signatures
+
+        private static void WriteCoreFunctionSignatures(StreamWriter sw, List<Function> functions)
         {
             sw.WriteLine("        #region Function signatures");
             sw.WriteLine();
@@ -122,6 +215,8 @@ namespace OpenTK.OpenGL.Bind
 
             foreach (Function f in functions)
             {
+                if (f.Extension)
+                    continue;
                 sw.WriteLine("            public delegate {0};", f.ToString());
             }
 
@@ -129,9 +224,11 @@ namespace OpenTK.OpenGL.Bind
             sw.WriteLine("        #endregion");
             sw.WriteLine();
         }
+
         #endregion
 
-        #region Write dll imports
+        #region Write core dll imports
+
         private static void WriteDllImports(StreamWriter sw, List<Function> functions)
         {
             sw.WriteLine("        #region Imports");
@@ -152,18 +249,21 @@ namespace OpenTK.OpenGL.Bind
             sw.WriteLine("        #endregion");
             sw.WriteLine();
         }
+
         #endregion
 
-        #region Write functions
+        #region Write core functions
 
-        private static void WriteFunctions(StreamWriter sw, List<Function> functions)
+        private static void WriteCoreFunctions(StreamWriter sw, List<Function> functions)
         {
-            sw.WriteLine("        #region Function initialisation");
+            sw.WriteLine("        #region Static Functions (and static initialisation)");
             sw.WriteLine();
 
             foreach (Function f in functions)
             {
-                sw.WriteLine("        public static Delegates.{0} {0};", f.Name);
+                if (f.Extension)
+                    continue;
+                sw.WriteLine("        public static Delegates.{0} {0} = new Delegates.{0}(Imports.{0});", f.Name);
             }
 
             sw.WriteLine();
@@ -173,9 +273,163 @@ namespace OpenTK.OpenGL.Bind
 
         #endregion
 
-        #region Write wrappers
+        #region Write core wrappers
 
-        public static void WriteWrappers(StreamWriter sw, List<Function> wrappers)
+        public static void WriteCoreWrappers(StreamWriter sw, List<Function> wrappers)
+        {
+            sw.WriteLine("        #region Wrappers");
+            sw.WriteLine();
+
+            if (wrappers != null)
+            {
+                foreach (Function f in wrappers)
+                {
+                    if (f.Extension)
+                        continue;
+
+                    sw.WriteLine("        #region {0}{1}", f.Name, f.Parameters.ToString());
+                    sw.WriteLine();
+
+                    sw.WriteLine("        public static");
+                    sw.WriteLine(f.ToString("        "));
+
+                    sw.WriteLine("        #endregion");
+                    sw.WriteLine();
+                }
+            }
+
+            sw.WriteLine("        #endregion");
+            sw.WriteLine();
+        }
+
+        #endregion
+
+        #region Write core constructor
+
+        private static void WriteCoreConstructor(StreamWriter sw, string class_name, List<Function> functions)
+        {
+            sw.WriteLine("        #region static Constructor");
+            sw.WriteLine();
+            sw.WriteLine("        static {0}()", class_name);
+            sw.WriteLine("        {");
+
+            List<String> import_list = new List<string>();
+
+            #region Older Windows Core
+
+            // Load core for older windows versions.
+            sw.WriteLine("            if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major < 6 || Environment.OSVersion.Platform == PlatformID.Win32Windows)");
+            sw.WriteLine("            {");
+            sw.WriteLine("                #region Older Windows Core");
+            import_list.Add("1.2");
+            import_list.Add("1.3");
+            import_list.Add("1.4");
+            import_list.Add("1.5");
+            import_list.Add("2.0");
+            import_list.Add("2.1");
+            foreach (Function f in functions)
+            {
+                if (!f.Extension)
+                    if (import_list.Contains(f.Version))
+                        sw.WriteLine("                {0} = (Delegates.{0})WindowsGetAddress(\"{1}\", typeof(Delegates.{0}));", f.Name, "gl"+ f.Name.TrimEnd('_'));
+            }
+            sw.WriteLine("                #endregion Older Windows Core");
+            sw.WriteLine("            }");
+        
+            #endregion
+            
+            #region Windows Vista Core
+
+            // Load core for windows vista.
+            sw.WriteLine("            else if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major >= 6)");
+            sw.WriteLine("            {");
+            sw.WriteLine("                #region Windows Vista Core");
+            import_list.Remove("1.2");
+            import_list.Remove("1.3");
+            import_list.Remove("1.4");
+            foreach (Function f in functions)
+            {
+                if (!f.Extension)
+                    if (import_list.Contains(f.Version))
+                        sw.WriteLine("                {0} = (Delegates.{0})WindowsGetAddress(\"{1}\", typeof(Delegates.{0}));", f.Name, "gl" + f.Name.TrimEnd('_'));
+            }
+            sw.WriteLine("                #endregion Windows Vista Core");
+            sw.WriteLine("            }");
+
+            #endregion
+
+            #region X11 Core
+
+            // Load core for windows X11.
+            sw.WriteLine("            else if (Environment.OSVersion.Platform == PlatformID.Unix)");
+            sw.WriteLine("            {");
+            sw.WriteLine("                #region X11 Core");
+            import_list.Remove("1.5");
+            import_list.Remove("1.6");
+            import_list.Remove("2.0");
+            import_list.Remove("2.1");
+            foreach (Function f in functions)
+            {
+                if (!f.Extension)
+                    if (import_list.Contains(f.Version))
+                        sw.WriteLine("                {0} = (Delegates.{0})WindowsGetAddress(\"{1}\", typeof(Delegates.{0}));", f.Name, "gl" + f.Name.TrimEnd('_'));
+            }
+            sw.WriteLine("                #endregion X11 Core");
+            sw.WriteLine("            }");
+
+            #endregion
+            
+            sw.WriteLine("        }");
+            sw.WriteLine("        #endregion static Constructor");
+        }
+
+        #endregion
+
+        #region Write extension function signatures
+
+        private static void WriteExtensionFunctionSignatures(StreamWriter sw, List<Function> functions)
+        {
+            sw.WriteLine("        #region Function signatures");
+            sw.WriteLine();
+            sw.WriteLine("        public static class Delegates");
+            sw.WriteLine("        {");
+
+            foreach (Function f in functions)
+            {
+                if (f.Extension)
+                    sw.WriteLine("            public delegate {0};", f.ToString());
+            }
+
+            sw.WriteLine("        }");
+            sw.WriteLine("        #endregion");
+            sw.WriteLine();
+        }
+
+        #endregion
+
+        #region Write extension functions
+
+        private static void WriteExtensionFunctions(StreamWriter sw, List<Function> functions)
+        {
+            sw.WriteLine("        #region Static Functions (and static initialisation)");
+            sw.WriteLine();
+
+            foreach (Function f in functions)
+            {
+                if (f.Extension)
+                    sw.WriteLine("        public static Delegates.{0} {0} = new Delegates.{0}(Imports.{0});", f.Name);
+            }
+
+            sw.WriteLine();
+            sw.WriteLine("        #endregion");
+            sw.WriteLine();
+        }
+
+        #endregion
+
+        #region Write extension wrappers
+
+        public static void WriteExtensionWrappers(StreamWriter sw, List<Function> wrappers)
         {
             sw.WriteLine("        #region Wrappers");
             sw.WriteLine();
@@ -184,6 +438,9 @@ namespace OpenTK.OpenGL.Bind
             {
                 foreach (Function w in wrappers)
                 {
+                    if (!w.Extension)
+                        continue;
+
                     sw.WriteLine("        #region {0}{1}", w.Name, w.Parameters.ToString());
                     sw.WriteLine();
 
@@ -199,5 +456,6 @@ namespace OpenTK.OpenGL.Bind
         }
 
         #endregion
+
     }
 }
\ No newline at end of file
diff --git a/Source/OpenGL/Bind/todo.txt b/Source/OpenGL/Bind/todo.txt
deleted file mode 100644
index 0ee3e14a..00000000
--- a/Source/OpenGL/Bind/todo.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-OpenTK.OpenGL.Bind 0.7.6 todos:
-
-+ Clean up the reader.
-+ Add more settings to Settings.cs (the name of the files to read).
-+ Comment the code.
\ No newline at end of file
diff --git a/Source/OpenGL/OpenGL/Bindings/GL.cs b/Source/OpenGL/OpenGL/Bindings/GL.cs
index cac720a5..61d31379 100644
--- a/Source/OpenGL/OpenGL/Bindings/GL.cs
+++ b/Source/OpenGL/OpenGL/Bindings/GL.cs
@@ -1,5 +1,6 @@
 #region License
-//Copyright (c) 2006 Stephen Apostolopoulos
+//THIS FILE IS AUTOMATICALLY GENERATED
+//DO NOT EDIT BY HAND!!
 //See license.txt for license info
 #endregion
 
@@ -7,8 +8,6 @@ using System;
 using System.Runtime.InteropServices;
 using System.Text;
 
-namespace OpenTK.OpenGL
-{
     #region Types
     using GLsizeiptrARB = System.IntPtr;
     using GLintptrARB = System.IntPtr;
@@ -40,5199 +39,13 @@ namespace OpenTK.OpenGL
     using GLuint64 = System.Int64;
     #endregion
 
-    #region Enums
-    public struct Enums
+namespace OpenTK.OpenGL
+{
+    static public partial class GL
     {
-        #region Missing Constants
-
-
-        #endregion
-
-        public enum PixelStoreParameter : uint
+        static public void Init()
         {
-            UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS,
-            UNPACK_LSB_FIRST = GetPName.UNPACK_LSB_FIRST,
-            UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX,
-            PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX,
-            UNPACK_ROW_LENGTH = GetPName.UNPACK_ROW_LENGTH,
-            UNPACK_ALIGNMENT = GetPName.UNPACK_ALIGNMENT,
-            UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT,
-            PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX,
-            PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX,
-            PACK_SKIP_ROWS = GetPName.PACK_SKIP_ROWS,
-            PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS,
-            UNPACK_SKIP_ROWS = GetPName.UNPACK_SKIP_ROWS,
-            UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT,
-            UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX,
-            PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX,
-            PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX,
-            PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX,
-            PACK_SKIP_PIXELS = GetPName.PACK_SKIP_PIXELS,
-            PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS,
-            PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX,
-            PACK_SWAP_BYTES = GetPName.PACK_SWAP_BYTES,
-            UNPACK_SWAP_BYTES = GetPName.UNPACK_SWAP_BYTES,
-            PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT,
-            UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS,
-            PACK_LSB_FIRST = GetPName.PACK_LSB_FIRST,
-            PACK_ALIGNMENT = GetPName.PACK_ALIGNMENT,
-            PACK_ROW_LENGTH = GetPName.PACK_ROW_LENGTH,
-            UNPACK_SKIP_PIXELS = GetPName.UNPACK_SKIP_PIXELS,
-            PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX,
-            PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT,
         }
-
-        public enum HintMode : uint
-        {
-            DONT_CARE = 0x1100,
-            NICEST = 0x1102,
-            FASTEST = 0x1101,
-        }
-
-        public enum ATI_pixel_format_float : uint
-        {
-            COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835,
-            TYPE_RGBA_FLOAT_ATI = 0x8820,
-        }
-
-        public enum INTEL_parallel_arrays : uint
-        {
-            VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5,
-            NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6,
-            COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7,
-            PARALLEL_ARRAYS_INTEL = 0x83F4,
-            TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8,
-        }
-
-        public enum HistogramTargetEXT : uint
-        {
-            HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
-            PROXY_HISTOGRAM_EXT = EXT_histogram.PROXY_HISTOGRAM_EXT,
-        }
-
-        public enum ARB_pixel_buffer_object : uint
-        {
-            PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED,
-            PIXEL_PACK_BUFFER_ARB = 0x88EB,
-            PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF,
-            PIXEL_UNPACK_BUFFER_ARB = 0x88EC,
-        }
-
-        public enum ColorTableTargetSGI : uint
-        {
-            TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
-            POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI,
-            PROXY_TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.PROXY_TEXTURE_COLOR_TABLE_SGI,
-            COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
-            PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI,
-            PROXY_COLOR_TABLE_SGI = SGI_color_table.PROXY_COLOR_TABLE_SGI,
-            PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI,
-            POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
-        }
-
-        public enum SGI_texture_color_table : uint
-        {
-            TEXTURE_COLOR_TABLE_SGI = 0x80BC,
-            PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD,
-        }
-
-        public enum OML_resample : uint
-        {
-            PACK_RESAMPLE_OML = 0x8984,
-            RESAMPLE_AVERAGE_OML = 0x8988,
-            RESAMPLE_REPLICATE_OML = 0x8986,
-            RESAMPLE_DECIMATE_OML = 0x8989,
-            UNPACK_RESAMPLE_OML = 0x8985,
-            RESAMPLE_ZERO_FILL_OML = 0x8987,
-        }
-
-        public enum WIN_phong_shading : uint
-        {
-            PHONG_WIN = 0x80EA,
-            PHONG_HINT_WIN = 0x80EB,
-        }
-
-        public enum SGIX_sprite : uint
-        {
-            SPRITE_SGIX = 0x8148,
-            SPRITE_MODE_SGIX = 0x8149,
-            SPRITE_TRANSLATION_SGIX = 0x814B,
-            SPRITE_AXIS_SGIX = 0x814A,
-            SPRITE_AXIAL_SGIX = 0x814C,
-            SPRITE_OBJECT_ALIGNED_SGIX = 0x814D,
-            SPRITE_EYE_ALIGNED_SGIX = 0x814E,
-        }
-
-        public enum EXT_pixel_transform_color_table : uint
-        {
-        }
-
-        public enum SGIX_async_pixel : uint
-        {
-            ASYNC_TEX_IMAGE_SGIX = 0x835C,
-            MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F,
-            ASYNC_DRAW_PIXELS_SGIX = 0x835D,
-            ASYNC_READ_PIXELS_SGIX = 0x835E,
-            MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360,
-            MAX_ASYNC_READ_PIXELS_SGIX = 0x8361,
-        }
-
-        public enum ARB_texture_env_add : uint
-        {
-        }
-
-        public enum BeginMode : uint
-        {
-            QUAD_STRIP = 0x0008,
-            POLYGON = 0x0009,
-            LINES = 0x0001,
-            TRIANGLES = 0x0004,
-            TRIANGLE_STRIP = 0x0005,
-            LINE_LOOP = 0x0002,
-            LINE_STRIP = 0x0003,
-            QUADS = 0x0007,
-            TRIANGLE_FAN = 0x0006,
-            POINTS = 0x0000,
-        }
-
-        public enum ListMode : uint
-        {
-            COMPILE = 0x1300,
-            COMPILE_AND_EXECUTE = 0x1301,
-        }
-
-        public enum GetMapQuery : uint
-        {
-            ORDER = 0x0A01,
-            DOMAIN = 0x0A02,
-            COEFF = 0x0A00,
-        }
-
-        public enum ARB_matrix_palette : uint
-        {
-            MAX_PALETTE_MATRICES_ARB = 0x8842,
-            CURRENT_MATRIX_INDEX_ARB = 0x8845,
-            MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849,
-            MATRIX_INDEX_ARRAY_ARB = 0x8844,
-            MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846,
-            CURRENT_PALETTE_MATRIX_ARB = 0x8843,
-            MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841,
-            MATRIX_PALETTE_ARB = 0x8840,
-            MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848,
-            MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847,
-        }
-
-        public enum TextureParameterName : uint
-        {
-            TEXTURE_BORDER_COLOR = GetTextureParameter.TEXTURE_BORDER_COLOR,
-            TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX,
-            TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX,
-            POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX,
-            TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX,
-            GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS,
-            TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX,
-            TEXTURE_COMPARE_OPERATOR_SGIX = SGIX_shadow.TEXTURE_COMPARE_OPERATOR_SGIX,
-            QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS,
-            TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX,
-            TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX,
-            TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX,
-            TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX,
-            TEXTURE_MAG_FILTER = 0x2800,
-            SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX,
-            TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS,
-            DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS,
-            TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX,
-            DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS,
-            TEXTURE_WRAP_S = 0x2802,
-            TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX,
-            POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX,
-            DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS,
-            TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT,
-            TEXTURE_MIN_FILTER = 0x2801,
-            TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX,
-            TEXTURE_WRAP_T = 0x2803,
-            TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX,
-            TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX,
-            TEXTURE_PRIORITY = GetTextureParameter.TEXTURE_PRIORITY,
-        }
-
-        public enum SGI_depth_pass_instrument : uint
-        {
-            DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311,
-            DEPTH_PASS_INSTRUMENT_SGIX = 0x8310,
-            DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312,
-        }
-
-        public enum FrontFaceDirection : uint
-        {
-            CCW = 0x0901,
-            CW = 0x0900,
-        }
-
-        public enum NV_point_sprite : uint
-        {
-            COORD_REPLACE_NV = 0x8862,
-            POINT_SPRITE_R_MODE_NV = 0x8863,
-            POINT_SPRITE_NV = 0x8861,
-        }
-
-        public enum INGR_palette_buffer : uint
-        {
-        }
-
-        public enum PolygonMode : uint
-        {
-            FILL = 0x1B02,
-            LINE = 0x1B01,
-            POINT = 0x1B00,
-        }
-
-        public enum NV_fog_distance : uint
-        {
-            EYE_PLANE = TextureGenParameter.EYE_PLANE,
-            FOG_DISTANCE_MODE_NV = 0x855A,
-            EYE_RADIAL_NV = 0x855B,
-            EYE_PLANE_ABSOLUTE_NV = 0x855C,
-        }
-
-        public enum MaterialFace : uint
-        {
-            BACK = DrawBufferMode.BACK,
-            FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
-            FRONT = DrawBufferMode.FRONT,
-        }
-
-        public enum BlendingFactorDest : uint
-        {
-            ZERO = 0,
-            ONE_MINUS_SRC_ALPHA = 0x0303,
-            ONE_MINUS_DST_ALPHA = 0x0305,
-            CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT,
-            DST_ALPHA = 0x0304,
-            CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT,
-            ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT,
-            ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT,
-            SRC_ALPHA = 0x0302,
-            SRC_COLOR = 0x0300,
-            ONE_MINUS_SRC_COLOR = 0x0301,
-            ONE = 1,
-        }
-
-        public enum MatrixMode : uint
-        {
-            PROJECTION = 0x1701,
-            MODELVIEW = 0x1700,
-            TEXTURE = 0x1702,
-        }
-
-        public enum TextureMagFilter : uint
-        {
-            LINEAR = 0x2601,
-            PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX,
-            FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
-            LINEAR_SHARPEN_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_SGIS,
-            PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX,
-            LINEAR_DETAIL_SGIS = SGIS_detail_texture.LINEAR_DETAIL_SGIS,
-            PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX,
-            NEAREST = 0x2600,
-            LINEAR_SHARPEN_COLOR_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_COLOR_SGIS,
-            LINEAR_SHARPEN_ALPHA_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_ALPHA_SGIS,
-            LINEAR_DETAIL_ALPHA_SGIS = SGIS_detail_texture.LINEAR_DETAIL_ALPHA_SGIS,
-            LINEAR_DETAIL_COLOR_SGIS = SGIS_detail_texture.LINEAR_DETAIL_COLOR_SGIS,
-        }
-
-        public enum NV_evaluators : uint
-        {
-            EVAL_VERTEX_ATTRIB4_NV = 0x86CA,
-            EVAL_VERTEX_ATTRIB5_NV = 0x86CB,
-            EVAL_VERTEX_ATTRIB15_NV = 0x86D5,
-            MAX_MAP_TESSELLATION_NV = 0x86D6,
-            EVAL_VERTEX_ATTRIB3_NV = 0x86C9,
-            EVAL_VERTEX_ATTRIB12_NV = 0x86D2,
-            EVAL_VERTEX_ATTRIB14_NV = 0x86D4,
-            EVAL_VERTEX_ATTRIB13_NV = 0x86D3,
-            MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7,
-            MAP_TESSELLATION_NV = 0x86C2,
-            MAP_ATTRIB_U_ORDER_NV = 0x86C3,
-            EVAL_VERTEX_ATTRIB8_NV = 0x86CE,
-            EVAL_VERTEX_ATTRIB11_NV = 0x86D1,
-            EVAL_VERTEX_ATTRIB9_NV = 0x86CF,
-            EVAL_VERTEX_ATTRIB7_NV = 0x86CD,
-            EVAL_VERTEX_ATTRIB10_NV = 0x86D0,
-            EVAL_VERTEX_ATTRIB2_NV = 0x86C8,
-            EVAL_VERTEX_ATTRIB0_NV = 0x86C6,
-            EVAL_2D_NV = 0x86C0,
-            EVAL_VERTEX_ATTRIB1_NV = 0x86C7,
-            MAP_ATTRIB_V_ORDER_NV = 0x86C4,
-            EVAL_TRIANGULAR_2D_NV = 0x86C1,
-            EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5,
-            EVAL_VERTEX_ATTRIB6_NV = 0x86CC,
-        }
-
-        public enum GetHistogramParameterPNameEXT : uint
-        {
-            HISTOGRAM_BLUE_SIZE_EXT = EXT_histogram.HISTOGRAM_BLUE_SIZE_EXT,
-            HISTOGRAM_FORMAT_EXT = EXT_histogram.HISTOGRAM_FORMAT_EXT,
-            HISTOGRAM_GREEN_SIZE_EXT = EXT_histogram.HISTOGRAM_GREEN_SIZE_EXT,
-            HISTOGRAM_ALPHA_SIZE_EXT = EXT_histogram.HISTOGRAM_ALPHA_SIZE_EXT,
-            HISTOGRAM_LUMINANCE_SIZE_EXT = EXT_histogram.HISTOGRAM_LUMINANCE_SIZE_EXT,
-            HISTOGRAM_RED_SIZE_EXT = EXT_histogram.HISTOGRAM_RED_SIZE_EXT,
-            HISTOGRAM_SINK_EXT = EXT_histogram.HISTOGRAM_SINK_EXT,
-            HISTOGRAM_WIDTH_EXT = EXT_histogram.HISTOGRAM_WIDTH_EXT,
-        }
-
-        public enum CullFaceMode : uint
-        {
-            BACK = DrawBufferMode.BACK,
-            FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
-            FRONT = DrawBufferMode.FRONT,
-        }
-
-        public enum ARB_color_buffer_float : uint
-        {
-            CLAMP_READ_COLOR_ARB = 0x891C,
-            CLAMP_FRAGMENT_COLOR_ARB = 0x891B,
-            FIXED_ONLY_ARB = 0x891D,
-            CLAMP_VERTEX_COLOR_ARB = 0x891A,
-            RGBA_FLOAT_MODE_ARB = 0x8820,
-        }
-
-        public enum ConvolutionBorderModeEXT : uint
-        {
-            REDUCE_EXT = EXT_convolution.REDUCE_EXT,
-        }
-
-        public enum SGIX_blend_alpha_minmax : uint
-        {
-            ALPHA_MAX_SGIX = 0x8321,
-            ASYNC_MARKER_SGIX = 0x8329,
-            ALPHA_MIN_SGIX = 0x8320,
-        }
-
-        public enum MinmaxTargetEXT : uint
-        {
-            MINMAX_EXT = EXT_histogram.MINMAX_EXT,
-        }
-
-        public enum FfdMaskSGIX : uint
-        {
-            GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002,
-            TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001,
-        }
-
-        public enum TextureEnvParameter : uint
-        {
-            TEXTURE_ENV_COLOR = 0x2201,
-            TEXTURE_ENV_MODE = 0x2200,
-        }
-
-        public enum ARB_shading_language_100 : uint
-        {
-            SHADING_LANGUAGE_VERSION_ARB = 0x8B8C,
-        }
-
-        public enum _3DFX_multisample : uint
-        {
-            SAMPLE_BUFFERS_3DFX = 0x86B3,
-            MULTISAMPLE_BIT_3DFX = 0x20000000,
-            MULTISAMPLE_3DFX = 0x86B2,
-            SAMPLES_3DFX = 0x86B4,
-        }
-
-        public enum DrawBufferMode : uint
-        {
-            FRONT_RIGHT = 0x0401,
-            AUX3 = 0x040C,
-            AUX1 = 0x040A,
-            FRONT_AND_BACK = 0x0408,
-            LEFT = 0x0406,
-            NONE = 0,
-            RIGHT = 0x0407,
-            BACK_RIGHT = 0x0403,
-            AUX2 = 0x040B,
-            AUX0 = 0x0409,
-            FRONT_LEFT = 0x0400,
-            BACK = 0x0405,
-            FRONT = 0x0404,
-            BACK_LEFT = 0x0402,
-        }
-
-        public enum ShadingModel : uint
-        {
-            SMOOTH = 0x1D01,
-            FLAT = 0x1D00,
-        }
-
-        public enum EXT_coordinate_frame : uint
-        {
-            BINORMAL_ARRAY_STRIDE_EXT = 0x8441,
-            BINORMAL_ARRAY_TYPE_EXT = 0x8440,
-            MAP1_TANGENT_EXT = 0x8444,
-            TANGENT_ARRAY_POINTER_EXT = 0x8442,
-            CURRENT_TANGENT_EXT = 0x843B,
-            MAP1_BINORMAL_EXT = 0x8446,
-            TANGENT_ARRAY_TYPE_EXT = 0x843E,
-            CURRENT_BINORMAL_EXT = 0x843C,
-            MAP2_TANGENT_EXT = 0x8445,
-            MAP2_BINORMAL_EXT = 0x8447,
-            BINORMAL_ARRAY_EXT = 0x843A,
-            TANGENT_ARRAY_STRIDE_EXT = 0x843F,
-            TANGENT_ARRAY_EXT = 0x8439,
-            BINORMAL_ARRAY_POINTER_EXT = 0x8443,
-        }
-
-        public enum EXT_texture3D : uint
-        {
-            TEXTURE_WRAP_R = 0x8072,
-            UNPACK_IMAGE_HEIGHT_EXT = 0x806E,
-            PROXY_TEXTURE_3D = 0x8070,
-            UNPACK_SKIP_IMAGES_EXT = 0x806D,
-            MAX_3D_TEXTURE_SIZE = 0x8073,
-            TEXTURE_3D_EXT = 0x806F,
-            PACK_SKIP_IMAGES = 0x806B,
-            PACK_IMAGE_HEIGHT = 0x806C,
-            PROXY_TEXTURE_3D_EXT = 0x8070,
-            MAX_3D_TEXTURE_SIZE_EXT = 0x8073,
-            TEXTURE_DEPTH_EXT = 0x8071,
-            TEXTURE_DEPTH = 0x8071,
-            PACK_SKIP_IMAGES_EXT = 0x806B,
-            TEXTURE_WRAP_R_EXT = 0x8072,
-            UNPACK_SKIP_IMAGES = 0x806D,
-            UNPACK_IMAGE_HEIGHT = 0x806E,
-            TEXTURE_3D = 0x806F,
-            PACK_IMAGE_HEIGHT_EXT = 0x806C,
-        }
-
-        public enum ColorMaterialParameter : uint
-        {
-            EMISSION = MaterialParameter.EMISSION,
-            DIFFUSE = LightParameter.DIFFUSE,
-            AMBIENT_AND_DIFFUSE = MaterialParameter.AMBIENT_AND_DIFFUSE,
-            SPECULAR = LightParameter.SPECULAR,
-            AMBIENT = LightParameter.AMBIENT,
-        }
-
-        public enum TextureWrapMode : uint
-        {
-            CLAMP_TO_BORDER_SGIS = SGIS_texture_border_clamp.CLAMP_TO_BORDER_SGIS,
-            CLAMP = 0x2900,
-            REPEAT = 0x2901,
-            CLAMP_TO_EDGE_SGIS = SGIS_texture_edge_clamp.CLAMP_TO_EDGE_SGIS,
-        }
-
-        public enum SGIX_interlace : uint
-        {
-            INTERLACE_SGIX = 0x8094,
-        }
-
-        public enum EXT_vertex_array : uint
-        {
-            TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092,
-            NORMAL_ARRAY_COUNT_EXT = 0x8080,
-            INDEX_ARRAY_TYPE_EXT = 0x8085,
-            VERTEX_ARRAY_TYPE_EXT = 0x807B,
-            INDEX_ARRAY_COUNT_EXT = 0x8087,
-            TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
-            COLOR_ARRAY_POINTER_EXT = 0x8090,
-            INDEX_ARRAY_POINTER_EXT = 0x8091,
-            COLOR_ARRAY_TYPE_EXT = 0x8082,
-            NORMAL_ARRAY_POINTER_EXT = 0x808F,
-            TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B,
-            VERTEX_ARRAY_SIZE_EXT = 0x807A,
-            VERTEX_ARRAY_STRIDE_EXT = 0x807C,
-            VERTEX_ARRAY_POINTER_EXT = 0x808E,
-            INDEX_ARRAY_STRIDE_EXT = 0x8086,
-            VERTEX_ARRAY_COUNT_EXT = 0x807D,
-            EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093,
-            TEXTURE_COORD_ARRAY_EXT = 0x8078,
-            VERTEX_ARRAY_EXT = 0x8074,
-            TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A,
-            COLOR_ARRAY_EXT = 0x8076,
-            COLOR_ARRAY_SIZE_EXT = 0x8081,
-            TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
-            NORMAL_ARRAY_TYPE_EXT = 0x807E,
-            NORMAL_ARRAY_STRIDE_EXT = 0x807F,
-            COLOR_ARRAY_COUNT_EXT = 0x8084,
-            EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C,
-            EDGE_FLAG_ARRAY_EXT = 0x8079,
-            INDEX_ARRAY_EXT = 0x8077,
-            NORMAL_ARRAY_EXT = 0x8075,
-            EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D,
-            COLOR_ARRAY_STRIDE_EXT = 0x8083,
-        }
-
-        public enum NV_texture_env_combine4 : uint
-        {
-            COMBINE4_NV = 0x8503,
-            SOURCE3_RGB_NV = 0x8583,
-            SOURCE3_ALPHA_NV = 0x858B,
-            OPERAND3_RGB_NV = 0x8593,
-            OPERAND3_ALPHA_NV = 0x859B,
-        }
-
-        public enum PixelCopyType : uint
-        {
-            DEPTH = 0x1801,
-            COLOR = 0x1800,
-            STENCIL = 0x1802,
-        }
-
-        public enum LightParameter : uint
-        {
-            POSITION = 0x1203,
-            SPOT_DIRECTION = 0x1204,
-            LINEAR_ATTENUATION = 0x1208,
-            SPOT_CUTOFF = 0x1206,
-            SPOT_EXPONENT = 0x1205,
-            CONSTANT_ATTENUATION = 0x1207,
-            QUADRATIC_ATTENUATION = 0x1209,
-            SPECULAR = 0x1202,
-            DIFFUSE = 0x1201,
-            AMBIENT = 0x1200,
-        }
-
-        public enum GetMinmaxParameterPNameEXT : uint
-        {
-            MINMAX_SINK_EXT = EXT_histogram.MINMAX_SINK_EXT,
-            MINMAX_FORMAT_EXT = EXT_histogram.MINMAX_FORMAT_EXT,
-        }
-
-        public enum ARB_imaging : uint
-        {
-            CONVOLUTION_WIDTH = 0x8018,
-            COLOR_MATRIX_STACK_DEPTH = 0x80B2,
-            BLEND_EQUATION = 0x8009,
-            COLOR_TABLE_BIAS = 0x80D7,
-            CONSTANT_BORDER = 0x8151,
-            HISTOGRAM = 0x8024,
-            COLOR_TABLE_GREEN_SIZE = 0x80DB,
-            HISTOGRAM_RED_SIZE = 0x8028,
-            CONSTANT_ALPHA = 0x8003,
-            TABLE_TOO_LARGE = 0x8031,
-            POST_CONVOLUTION_GREEN_SCALE = 0x801D,
-            MINMAX_SINK = 0x8030,
-            PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
-            COLOR_TABLE_SCALE = 0x80D6,
-            COLOR_MATRIX = 0x80B1,
-            CONVOLUTION_FILTER_SCALE = 0x8014,
-            BLEND_COLOR = 0x8005,
-            MIN = 0x8007,
-            HISTOGRAM_SINK = 0x802D,
-            POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5,
-            SEPARABLE_2D = 0x8012,
-            FUNC_REVERSE_SUBTRACT = 0x800B,
-            CONVOLUTION_FORMAT = 0x8017,
-            REPLICATE_BORDER = 0x8153,
-            CONSTANT_COLOR = 0x8001,
-            COLOR_TABLE = 0x80D0,
-            POST_CONVOLUTION_BLUE_SCALE = 0x801E,
-            FUNC_ADD = 0x8006,
-            CONVOLUTION_2D = 0x8011,
-            POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB,
-            POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7,
-            MINMAX = 0x802E,
-            POST_CONVOLUTION_ALPHA_BIAS = 0x8023,
-            POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6,
-            POST_COLOR_MATRIX_RED_BIAS = 0x80B8,
-            HISTOGRAM_BLUE_SIZE = 0x802A,
-            POST_CONVOLUTION_BLUE_BIAS = 0x8022,
-            COLOR_TABLE_FORMAT = 0x80D8,
-            POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2,
-            CONVOLUTION_HEIGHT = 0x8019,
-            POST_CONVOLUTION_COLOR_TABLE = 0x80D1,
-            MINMAX_FORMAT = 0x802F,
-            COLOR_TABLE_ALPHA_SIZE = 0x80DD,
-            POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA,
-            PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
-            PROXY_COLOR_TABLE = 0x80D3,
-            HISTOGRAM_ALPHA_SIZE = 0x802B,
-            MAX_CONVOLUTION_WIDTH = 0x801A,
-            POST_COLOR_MATRIX_RED_SCALE = 0x80B4,
-            POST_CONVOLUTION_ALPHA_SCALE = 0x801F,
-            CONVOLUTION_BORDER_COLOR = 0x8154,
-            COLOR_TABLE_BLUE_SIZE = 0x80DC,
-            ONE_MINUS_CONSTANT_COLOR = 0x8002,
-            COLOR_TABLE_LUMINANCE_SIZE = 0x80DE,
-            POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9,
-            ONE_MINUS_CONSTANT_ALPHA = 0x8004,
-            FUNC_SUBTRACT = 0x800A,
-            COLOR_TABLE_INTENSITY_SIZE = 0x80DF,
-            REDUCE = 0x8016,
-            COLOR_TABLE_RED_SIZE = 0x80DA,
-            CONVOLUTION_BORDER_MODE = 0x8013,
-            HISTOGRAM_GREEN_SIZE = 0x8029,
-            POST_CONVOLUTION_GREEN_BIAS = 0x8021,
-            HISTOGRAM_FORMAT = 0x8027,
-            CONVOLUTION_1D = 0x8010,
-            POST_CONVOLUTION_RED_BIAS = 0x8020,
-            MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3,
-            COLOR_TABLE_WIDTH = 0x80D9,
-            POST_CONVOLUTION_RED_SCALE = 0x801C,
-            MAX = 0x8008,
-            PROXY_HISTOGRAM = 0x8025,
-            MAX_CONVOLUTION_HEIGHT = 0x801B,
-            CONVOLUTION_FILTER_BIAS = 0x8015,
-            HISTOGRAM_WIDTH = 0x8026,
-            HISTOGRAM_LUMINANCE_SIZE = 0x802C,
-        }
-
-        public enum NV_vertex_program2_option : uint
-        {
-            MAX_PROGRAM_CALL_DEPTH_NV = NV_fragment_program2.MAX_PROGRAM_CALL_DEPTH_NV,
-            MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = NV_fragment_program2.MAX_PROGRAM_EXEC_INSTRUCTIONS_NV,
-        }
-
-        public enum NV_primitive_restart : uint
-        {
-            PRIMITIVE_RESTART_NV = 0x8558,
-            PRIMITIVE_RESTART_INDEX_NV = 0x8559,
-        }
-
-        public enum NV_vertex_program : uint
-        {
-            VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643,
-            MAP1_VERTEX_ATTRIB12_4_NV = 0x866C,
-            ATTRIB_ARRAY_SIZE_NV = 0x8623,
-            MATRIX7_NV = 0x8637,
-            MAP2_VERTEX_ATTRIB14_4_NV = 0x867E,
-            VERTEX_ATTRIB_ARRAY2_NV = 0x8652,
-            MAP2_VERTEX_ATTRIB15_4_NV = 0x867F,
-            VERTEX_ATTRIB_ARRAY9_NV = 0x8659,
-            MAP2_VERTEX_ATTRIB12_4_NV = 0x867C,
-            MAP2_VERTEX_ATTRIB3_4_NV = 0x8673,
-            VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642,
-            MODELVIEW_PROJECTION_NV = 0x8629,
-            MAP2_VERTEX_ATTRIB2_4_NV = 0x8672,
-            MAP2_VERTEX_ATTRIB11_4_NV = 0x867B,
-            VERTEX_ATTRIB_ARRAY8_NV = 0x8658,
-            CURRENT_MATRIX_NV = 0x8641,
-            VERTEX_PROGRAM_BINDING_NV = 0x864A,
-            VERTEX_ATTRIB_ARRAY0_NV = 0x8650,
-            MAP2_VERTEX_ATTRIB1_4_NV = 0x8671,
-            VERTEX_ATTRIB_ARRAY7_NV = 0x8657,
-            PROGRAM_PARAMETER_NV = 0x8644,
-            VERTEX_PROGRAM_NV = 0x8620,
-            ATTRIB_ARRAY_POINTER_NV = 0x8645,
-            PROGRAM_STRING_NV = 0x8628,
-            MAP2_VERTEX_ATTRIB0_4_NV = 0x8670,
-            VERTEX_ATTRIB_ARRAY4_NV = 0x8654,
-            MAP1_VERTEX_ATTRIB7_4_NV = 0x8667,
-            PROGRAM_TARGET_NV = 0x8646,
-            MAP1_VERTEX_ATTRIB11_4_NV = 0x866B,
-            MAP2_VERTEX_ATTRIB7_4_NV = 0x8677,
-            VERTEX_ATTRIB_ARRAY6_NV = 0x8656,
-            MAP1_VERTEX_ATTRIB8_4_NV = 0x8668,
-            VERTEX_ATTRIB_ARRAY5_NV = 0x8655,
-            VERTEX_STATE_PROGRAM_NV = 0x8621,
-            MAP1_VERTEX_ATTRIB9_4_NV = 0x8669,
-            IDENTITY_NV = 0x862A,
-            MAP2_VERTEX_ATTRIB6_4_NV = 0x8676,
-            MATRIX4_NV = 0x8634,
-            PROGRAM_RESIDENT_NV = 0x8647,
-            MAP1_VERTEX_ATTRIB5_4_NV = 0x8665,
-            MAP2_VERTEX_ATTRIB4_4_NV = 0x8674,
-            MAP1_VERTEX_ATTRIB6_4_NV = 0x8666,
-            MAP1_VERTEX_ATTRIB13_4_NV = 0x866D,
-            MAP2_VERTEX_ATTRIB5_4_NV = 0x8675,
-            MAP1_VERTEX_ATTRIB10_4_NV = 0x866A,
-            MAP1_VERTEX_ATTRIB1_4_NV = 0x8661,
-            MAP2_VERTEX_ATTRIB13_4_NV = 0x867D,
-            VERTEX_ATTRIB_ARRAY3_NV = 0x8653,
-            ATTRIB_ARRAY_TYPE_NV = 0x8625,
-            MAP1_VERTEX_ATTRIB14_4_NV = 0x866E,
-            MAP1_VERTEX_ATTRIB2_4_NV = 0x8662,
-            TRACK_MATRIX_TRANSFORM_NV = 0x8649,
-            MATRIX0_NV = 0x8630,
-            MAP1_VERTEX_ATTRIB3_4_NV = 0x8663,
-            MAP2_VERTEX_ATTRIB10_4_NV = 0x867A,
-            INVERSE_NV = 0x862B,
-            VERTEX_ATTRIB_ARRAY14_NV = 0x865E,
-            VERTEX_ATTRIB_ARRAY15_NV = 0x865F,
-            VERTEX_ATTRIB_ARRAY12_NV = 0x865C,
-            MAX_TRACK_MATRICES_NV = 0x862F,
-            MAP1_VERTEX_ATTRIB4_4_NV = 0x8664,
-            VERTEX_ATTRIB_ARRAY11_NV = 0x865B,
-            VERTEX_ATTRIB_ARRAY13_NV = 0x865D,
-            VERTEX_ATTRIB_ARRAY10_NV = 0x865A,
-            MATRIX6_NV = 0x8636,
-            PROGRAM_LENGTH_NV = 0x8627,
-            MAP1_VERTEX_ATTRIB0_4_NV = 0x8660,
-            VERTEX_ATTRIB_ARRAY1_NV = 0x8651,
-            MAP1_VERTEX_ATTRIB15_4_NV = 0x866F,
-            MAP2_VERTEX_ATTRIB9_4_NV = 0x8679,
-            INVERSE_TRANSPOSE_NV = 0x862D,
-            PROGRAM_ERROR_POSITION_NV = 0x864B,
-            TRACK_MATRIX_NV = 0x8648,
-            MAP2_VERTEX_ATTRIB8_4_NV = 0x8678,
-            CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640,
-            MATRIX1_NV = 0x8631,
-            ATTRIB_ARRAY_STRIDE_NV = 0x8624,
-            MATRIX3_NV = 0x8633,
-            MATRIX5_NV = 0x8635,
-            TRANSPOSE_NV = 0x862C,
-            MATRIX2_NV = 0x8632,
-            CURRENT_ATTRIB_NV = 0x8626,
-            MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E,
-        }
-
-        public enum ARB_shadow_ambient : uint
-        {
-            TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF,
-        }
-
-        public enum FragmentLightModelParameterSGIX : uint
-        {
-            FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX,
-            FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX,
-            FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX,
-            FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX,
-        }
-
-        public enum StringName : uint
-        {
-            EXTENSIONS = 0x1F03,
-            VERSION = 0x1F02,
-            RENDERER = 0x1F01,
-            VENDOR = 0x1F00,
-        }
-
-        public enum MESA_pack_invert : uint
-        {
-            PACK_INVERT_MESA = 0x8758,
-        }
-
-        public enum NV_texgen_reflection : uint
-        {
-            NORMAL_MAP_NV = 0x8511,
-            REFLECTION_MAP_NV = 0x8512,
-        }
-
-        public enum FfdTargetSGIX : uint
-        {
-            GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX,
-            TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX,
-        }
-
-        public enum EXT_framebuffer_blit : uint
-        {
-            DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CAA,
-            READ_FRAMEBUFFER_BINDING_EXT = EXT_framebuffer_object.FRAMEBUFFER_BINDING_EXT,
-            READ_FRAMEBUFFER_EXT = 0x8CA8,
-            DRAW_FRAMEBUFFER_EXT = 0x8CA9,
-        }
-
-        public enum EnableCap : uint
-        {
-            MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3,
-            MAP2_NORMAL = GetPName.MAP2_NORMAL,
-            FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX,
-            CLIP_PLANE4 = GetPName.CLIP_PLANE4,
-            ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX,
-            FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX,
-            HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
-            LIGHT3 = GetPName.LIGHT3,
-            POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI,
-            CLIP_PLANE3 = GetPName.CLIP_PLANE3,
-            TEXTURE_COORD_ARRAY = GetPName.TEXTURE_COORD_ARRAY,
-            FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX,
-            CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
-            ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX,
-            LIGHT4 = GetPName.LIGHT4,
-            MAP2_INDEX = GetPName.MAP2_INDEX,
-            MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1,
-            POLYGON_OFFSET_POINT = GetPName.POLYGON_OFFSET_POINT,
-            ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX,
-            TEXTURE_1D = GetPName.TEXTURE_1D,
-            CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
-            TEXTURE_2D = GetPName.TEXTURE_2D,
-            MAP1_COLOR_4 = GetPName.MAP1_COLOR_4,
-            INDEX_LOGIC_OP = GetPName.INDEX_LOGIC_OP,
-            RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT,
-            FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX,
-            SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS,
-            LINE_STIPPLE = GetPName.LINE_STIPPLE,
-            POLYGON_OFFSET_FILL = GetPName.POLYGON_OFFSET_FILL,
-            LIGHT0 = GetPName.LIGHT0,
-            FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX,
-            CLIP_PLANE2 = GetPName.CLIP_PLANE2,
-            LIGHT5 = GetPName.LIGHT5,
-            FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX,
-            REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX,
-            SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS,
-            CLIP_PLANE1 = GetPName.CLIP_PLANE1,
-            COLOR_LOGIC_OP = GetPName.COLOR_LOGIC_OP,
-            FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX,
-            ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX,
-            MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4,
-            MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2,
-            NORMAL_ARRAY = GetPName.NORMAL_ARRAY,
-            FOG = GetPName.FOG,
-            CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX,
-            POINT_SMOOTH = GetPName.POINT_SMOOTH,
-            SCISSOR_TEST = GetPName.SCISSOR_TEST,
-            INDEX_ARRAY = GetPName.INDEX_ARRAY,
-            TEXTURE_GEN_S = GetPName.TEXTURE_GEN_S,
-            TEXTURE_GEN_R = GetPName.TEXTURE_GEN_R,
-            TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
-            NORMALIZE = GetPName.NORMALIZE,
-            CULL_FACE = GetPName.CULL_FACE,
-            LIGHT1 = GetPName.LIGHT1,
-            MAP1_NORMAL = GetPName.MAP1_NORMAL,
-            DEPTH_TEST = GetPName.DEPTH_TEST,
-            FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX,
-            MINMAX_EXT = EXT_histogram.MINMAX_EXT,
-            POLYGON_OFFSET_LINE = GetPName.POLYGON_OFFSET_LINE,
-            COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
-            MAP1_INDEX = GetPName.MAP1_INDEX,
-            AUTO_NORMAL = GetPName.AUTO_NORMAL,
-            POLYGON_SMOOTH = GetPName.POLYGON_SMOOTH,
-            POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
-            PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX,
-            CLIP_PLANE0 = GetPName.CLIP_PLANE0,
-            SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT,
-            POLYGON_STIPPLE = GetPName.POLYGON_STIPPLE,
-            SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS,
-            MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3,
-            MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3,
-            IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX,
-            TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
-            FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX,
-            PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS,
-            LIGHT6 = GetPName.LIGHT6,
-            ALPHA_TEST = GetPName.ALPHA_TEST,
-            STENCIL_TEST = GetPName.STENCIL_TEST,
-            BLEND = GetPName.BLEND,
-            MAP2_COLOR_4 = GetPName.MAP2_COLOR_4,
-            FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX,
-            FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
-            LIGHTING = GetPName.LIGHTING,
-            TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
-            CLIP_PLANE5 = GetPName.CLIP_PLANE5,
-            LINE_SMOOTH = GetPName.LINE_SMOOTH,
-            SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
-            DITHER = GetPName.DITHER,
-            INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX,
-            LIGHT2 = GetPName.LIGHT2,
-            TEXTURE_GEN_Q = GetPName.TEXTURE_GEN_Q,
-            EDGE_FLAG_ARRAY = GetPName.EDGE_FLAG_ARRAY,
-            COLOR_ARRAY = GetPName.COLOR_ARRAY,
-            TEXTURE_GEN_T = GetPName.TEXTURE_GEN_T,
-            MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4,
-            MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2,
-            MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4,
-            LIGHT7 = GetPName.LIGHT7,
-            SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX,
-            FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX,
-            MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3,
-            MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1,
-            MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4,
-            MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS,
-            VERTEX_ARRAY = GetPName.VERTEX_ARRAY,
-            COLOR_MATERIAL = GetPName.COLOR_MATERIAL,
-        }
-
-        public enum EXT_bgra : uint
-        {
-            BGRA = 0x80E1,
-            BGR_EXT = 0x80E0,
-            BGRA_EXT = 0x80E1,
-            BGR = 0x80E0,
-        }
-
-        public enum SGIS_point_line_texgen : uint
-        {
-            EYE_DISTANCE_TO_LINE_SGIS = 0x81F2,
-            EYE_LINE_SGIS = 0x81F6,
-            OBJECT_LINE_SGIS = 0x81F7,
-            OBJECT_POINT_SGIS = 0x81F5,
-            OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1,
-            EYE_POINT_SGIS = 0x81F4,
-            OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3,
-            EYE_DISTANCE_TO_POINT_SGIS = 0x81F0,
-        }
-
-        public enum EXT_texture_env_dot3 : uint
-        {
-            DOT3_RGB_EXT = 0x8740,
-            DOT3_RGBA_EXT = 0x8741,
-        }
-
-        public enum _3DFX_texture_compression_FXT1 : uint
-        {
-            COMPRESSED_RGBA_FXT1_3DFX = 0x86B1,
-            COMPRESSED_RGB_FXT1_3DFX = 0x86B0,
-        }
-
-        public enum REND_screen_coordinates : uint
-        {
-            SCREEN_COORDINATES_REND = 0x8490,
-            INVERTED_SCREEN_W_REND = 0x8491,
-        }
-
-        public enum SUN_triangle_list : uint
-        {
-            R1UI_N3F_V3F_SUN = 0x85C7,
-            REPLACE_MIDDLE_SUN = 0x0002,
-            REPLACE_OLDEST_SUN = 0x0003,
-            R1UI_V3F_SUN = 0x85C4,
-            REPLACEMENT_CODE_SUN = 0x81D8,
-            R1UI_T2F_N3F_V3F_SUN = 0x85CA,
-            RESTART_SUN = 0x0001,
-            REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2,
-            R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB,
-            R1UI_C4F_N3F_V3F_SUN = 0x85C8,
-            R1UI_T2F_V3F_SUN = 0x85C9,
-            TRIANGLE_LIST_SUN = 0x81D7,
-            REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1,
-            R1UI_C3F_V3F_SUN = 0x85C6,
-            R1UI_C4UB_V3F_SUN = 0x85C5,
-            REPLACEMENT_CODE_ARRAY_SUN = 0x85C0,
-            REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3,
-        }
-
-        public enum WIN_specular_fog : uint
-        {
-            FOG_SPECULAR_TEXTURE_WIN = 0x80EC,
-        }
-
-        public enum EXT_paletted_texture : uint
-        {
-            COLOR_INDEX1_EXT = 0x80E2,
-            TEXTURE_INDEX_SIZE_EXT = 0x80ED,
-            COLOR_INDEX8_EXT = 0x80E5,
-            COLOR_INDEX4_EXT = 0x80E4,
-            COLOR_INDEX12_EXT = 0x80E6,
-            COLOR_INDEX2_EXT = 0x80E3,
-            COLOR_INDEX16_EXT = 0x80E7,
-        }
-
-        public enum LogicOp : uint
-        {
-            SET = 0x150F,
-            EQUIV = 0x1509,
-            NAND = 0x150E,
-            NOR = 0x1508,
-            XOR = 0x1506,
-            OR = 0x1507,
-            COPY_INVERTED = 0x150C,
-            AND_INVERTED = 0x1504,
-            INVERT = 0x150A,
-            AND_REVERSE = 0x1502,
-            NOOP = 0x1505,
-            CLEAR = 0x1500,
-            OR_REVERSE = 0x150B,
-            OR_INVERTED = 0x150D,
-            AND = 0x1501,
-            COPY = 0x1503,
-        }
-
-        public enum EXT_index_func : uint
-        {
-            INDEX_TEST_FUNC_EXT = 0x81B6,
-            INDEX_TEST_EXT = 0x81B5,
-            INDEX_TEST_REF_EXT = 0x81B7,
-        }
-
-        public enum MESA_window_pos : uint
-        {
-        }
-
-        public enum DepthFunction : uint
-        {
-            NEVER = AlphaFunction.NEVER,
-            GEQUAL = AlphaFunction.GEQUAL,
-            GREATER = AlphaFunction.GREATER,
-            ALWAYS = AlphaFunction.ALWAYS,
-            LEQUAL = AlphaFunction.LEQUAL,
-            NOTEQUAL = AlphaFunction.NOTEQUAL,
-            EQUAL = AlphaFunction.EQUAL,
-            LESS = AlphaFunction.LESS,
-        }
-
-        public enum ARB_texture_non_power_of_two : uint
-        {
-        }
-
-        public enum SGIX_resample : uint
-        {
-            UNPACK_RESAMPLE_SGIX = 0x842D,
-            RESAMPLE_DECIMATE_SGIX = 0x8430,
-            RESAMPLE_REPLICATE_SGIX = 0x842E,
-            PACK_RESAMPLE_SGIX = 0x842C,
-            RESAMPLE_ZERO_FILL_SGIX = 0x842F,
-        }
-
-        public enum TextureFilterFuncSGIS : uint
-        {
-            FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
-        }
-
-        public enum ARB_fragment_program : uint
-        {
-            MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E,
-            PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805,
-            MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C,
-            MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810,
-            MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B,
-            MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872,
-            MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F,
-            MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D,
-            PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809,
-            PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806,
-            PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807,
-            PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A,
-            FRAGMENT_PROGRAM_ARB = 0x8804,
-            PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808,
-            MAX_TEXTURE_COORDS_ARB = 0x8871,
-        }
-
-        public enum SGIX_ycrcba : uint
-        {
-            YCRCBA_SGIX = 0x8319,
-            YCRCB_SGIX = 0x8318,
-        }
-
-        public enum EXT_convolution : uint
-        {
-            CONVOLUTION_WIDTH = 0x8018,
-            CONVOLUTION_1D = 0x8010,
-            CONVOLUTION_FILTER_SCALE_EXT = 0x8014,
-            CONVOLUTION_2D = 0x8011,
-            CONVOLUTION_WIDTH_EXT = 0x8018,
-            POST_CONVOLUTION_ALPHA_BIAS = 0x8023,
-            POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F,
-            POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022,
-            CONVOLUTION_FILTER_SCALE = 0x8014,
-            POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D,
-            SEPARABLE_2D = 0x8012,
-            CONVOLUTION_FORMAT = 0x8017,
-            POST_CONVOLUTION_BLUE_SCALE = 0x801E,
-            CONVOLUTION_BORDER_MODE_EXT = 0x8013,
-            POST_CONVOLUTION_GREEN_SCALE = 0x801D,
-            POST_CONVOLUTION_RED_SCALE_EXT = 0x801C,
-            REDUCE_EXT = 0x8016,
-            CONVOLUTION_1D_EXT = 0x8010,
-            MAX_CONVOLUTION_WIDTH_EXT = 0x801A,
-            CONVOLUTION_FORMAT_EXT = 0x8017,
-            POST_CONVOLUTION_BLUE_BIAS = 0x8022,
-            CONVOLUTION_HEIGHT = 0x8019,
-            SEPARABLE_2D_EXT = 0x8012,
-            CONVOLUTION_2D_EXT = 0x8011,
-            MAX_CONVOLUTION_WIDTH = 0x801A,
-            POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023,
-            POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021,
-            POST_CONVOLUTION_RED_BIAS_EXT = 0x8020,
-            REDUCE = 0x8016,
-            MAX_CONVOLUTION_HEIGHT_EXT = 0x801B,
-            CONVOLUTION_BORDER_MODE = 0x8013,
-            POST_CONVOLUTION_ALPHA_SCALE = 0x801F,
-            POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E,
-            POST_CONVOLUTION_RED_BIAS = 0x8020,
-            CONVOLUTION_FILTER_BIAS_EXT = 0x8015,
-            POST_CONVOLUTION_RED_SCALE = 0x801C,
-            CONVOLUTION_HEIGHT_EXT = 0x8019,
-            MAX_CONVOLUTION_HEIGHT = 0x801B,
-            CONVOLUTION_FILTER_BIAS = 0x8015,
-            POST_CONVOLUTION_GREEN_BIAS = 0x8021,
-        }
-
-        public enum MaterialParameter : uint
-        {
-            EMISSION = 0x1600,
-            DIFFUSE = LightParameter.DIFFUSE,
-            AMBIENT_AND_DIFFUSE = 0x1602,
-            SHININESS = 0x1601,
-            SPECULAR = LightParameter.SPECULAR,
-            AMBIENT = LightParameter.AMBIENT,
-            COLOR_INDEXES = 0x1603,
-        }
-
-        public enum EXT_index_texture : uint
-        {
-        }
-
-        public enum SeparableTargetEXT : uint
-        {
-            SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
-        }
-
-        public enum HP_convolution_border_modes : uint
-        {
-            IGNORE_BORDER_HP = 0x8150,
-            CONVOLUTION_BORDER_COLOR = 0x8154,
-            CONVOLUTION_BORDER_COLOR_HP = 0x8154,
-            REPLICATE_BORDER_HP = 0x8153,
-            CONSTANT_BORDER = 0x8151,
-            CONSTANT_BORDER_HP = 0x8151,
-            REPLICATE_BORDER = 0x8153,
-        }
-
-        public enum NV_vertex_program3 : uint
-        {
-            MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = ARB_vertex_shader.MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,
-        }
-
-        public enum NV_blend_square : uint
-        {
-        }
-
-        public enum PointParameterNameSGIS : uint
-        {
-            DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS,
-            POINT_SIZE_MAX_SGIS = SGIS_point_parameters.POINT_SIZE_MAX_SGIS,
-            POINT_FADE_THRESHOLD_SIZE_SGIS = SGIS_point_parameters.POINT_FADE_THRESHOLD_SIZE_SGIS,
-            POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_SGIS,
-        }
-
-        public enum EXT_texture_mirror_clamp : uint
-        {
-            MIRROR_CLAMP_TO_BORDER_EXT = 0x8912,
-            MIRROR_CLAMP_TO_EDGE_EXT = 0x8743,
-            MIRROR_CLAMP_EXT = 0x8742,
-        }
-
-        public enum NV_pixel_data_range : uint
-        {
-            READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B,
-            WRITE_PIXEL_DATA_RANGE_NV = 0x8878,
-            WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C,
-            READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D,
-            WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A,
-            READ_PIXEL_DATA_RANGE_NV = 0x8879,
-        }
-
-        public enum PixelInternalFormat : uint
-        {
-            LUMINANCE12_ALPHA12 = 0x8047,
-            DUAL_LUMINANCE16_SGIS = SGIS_texture_select.DUAL_LUMINANCE16_SGIS,
-            QUAD_LUMINANCE8_SGIS = SGIS_texture_select.QUAD_LUMINANCE8_SGIS,
-            RGBA16 = 0x805B,
-            ALPHA_ICC_SGIX = SGIX_icc_texture.ALPHA_ICC_SGIX,
-            LUMINANCE12 = 0x8041,
-            DUAL_ALPHA4_SGIS = SGIS_texture_select.DUAL_ALPHA4_SGIS,
-            INTENSITY4 = 0x804A,
-            RGBA12 = 0x805A,
-            INTENSITY8 = 0x804B,
-            DUAL_ALPHA8_SGIS = SGIS_texture_select.DUAL_ALPHA8_SGIS,
-            DEPTH_COMPONENT16_SGIX = SGIX_depth_texture.DEPTH_COMPONENT16_SGIX,
-            ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX,
-            DUAL_INTENSITY12_SGIS = SGIS_texture_select.DUAL_INTENSITY12_SGIS,
-            LUMINANCE16 = 0x8042,
-            LUMINANCE_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ICC_SGIX,
-            DEPTH_COMPONENT24_SGIX = SGIX_depth_texture.DEPTH_COMPONENT24_SGIX,
-            INTENSITY = 0x8049,
-            QUAD_ALPHA4_SGIS = SGIS_texture_select.QUAD_ALPHA4_SGIS,
-            ALPHA12 = 0x803D,
-            INTENSITY_ICC_SGIX = SGIX_icc_texture.INTENSITY_ICC_SGIX,
-            LUMINANCE4 = 0x803F,
-            LUMINANCE_ALPHA_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ALPHA_ICC_SGIX,
-            RGB_ICC_SGIX = SGIX_icc_texture.RGB_ICC_SGIX,
-            LUMINANCE4_ALPHA4 = 0x8043,
-            INTENSITY16_ICC_SGIX = SGIX_icc_texture.INTENSITY16_ICC_SGIX,
-            RGBA_ICC_SGIX = SGIX_icc_texture.RGBA_ICC_SGIX,
-            DUAL_LUMINANCE12_SGIS = SGIS_texture_select.DUAL_LUMINANCE12_SGIS,
-            ALPHA16 = 0x803E,
-            DUAL_ALPHA16_SGIS = SGIS_texture_select.DUAL_ALPHA16_SGIS,
-            DUAL_ALPHA12_SGIS = SGIS_texture_select.DUAL_ALPHA12_SGIS,
-            RGB2_EXT = EXT_texture.RGB2_EXT,
-            LUMINANCE8 = 0x8040,
-            QUAD_INTENSITY8_SGIS = SGIS_texture_select.QUAD_INTENSITY8_SGIS,
-            DUAL_LUMINANCE_ALPHA4_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA4_SGIS,
-            LUMINANCE12_ALPHA4 = 0x8046,
-            QUAD_LUMINANCE4_SGIS = SGIS_texture_select.QUAD_LUMINANCE4_SGIS,
-            RGB5 = 0x8050,
-            DUAL_LUMINANCE_ALPHA8_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA8_SGIS,
-            LUMINANCE8_ALPHA8 = 0x8045,
-            DUAL_INTENSITY8_SGIS = SGIS_texture_select.DUAL_INTENSITY8_SGIS,
-            RGB8 = 0x8051,
-            R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX,
-            QUAD_ALPHA8_SGIS = SGIS_texture_select.QUAD_ALPHA8_SGIS,
-            DUAL_INTENSITY4_SGIS = SGIS_texture_select.DUAL_INTENSITY4_SGIS,
-            RGB10_A2 = 0x8059,
-            INTENSITY12 = 0x804C,
-            RGBA4 = 0x8056,
-            RGB5_A1 = 0x8057,
-            R3_G3_B2 = 0x2A10,
-            R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX,
-            RGBA2 = 0x8055,
-            DUAL_INTENSITY16_SGIS = SGIS_texture_select.DUAL_INTENSITY16_SGIS,
-            QUAD_INTENSITY4_SGIS = SGIS_texture_select.QUAD_INTENSITY4_SGIS,
-            DUAL_LUMINANCE8_SGIS = SGIS_texture_select.DUAL_LUMINANCE8_SGIS,
-            RGB16 = 0x8054,
-            ALPHA4 = 0x803B,
-            RGBA8 = 0x8058,
-            INTENSITY16 = 0x804D,
-            LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX,
-            LUMINANCE16_ALPHA16 = 0x8048,
-            LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX,
-            ALPHA8 = 0x803C,
-            RGB4 = 0x804F,
-            DEPTH_COMPONENT32_SGIX = SGIX_depth_texture.DEPTH_COMPONENT32_SGIX,
-            RGB10 = 0x8052,
-            RGB12 = 0x8053,
-            LUMINANCE6_ALPHA2 = 0x8044,
-            DUAL_LUMINANCE4_SGIS = SGIS_texture_select.DUAL_LUMINANCE4_SGIS,
-        }
-
-        public enum ARB_vertex_blend : uint
-        {
-            MODELVIEW5_ARB = 0x8725,
-            MODELVIEW0_ARB = 0x1700,
-            ACTIVE_VERTEX_UNITS_ARB = 0x86A5,
-            MODELVIEW6_ARB = 0x8726,
-            MODELVIEW4_ARB = 0x8724,
-            WEIGHT_ARRAY_ARB = 0x86AD,
-            MODELVIEW15_ARB = 0x872F,
-            MODELVIEW10_ARB = 0x872A,
-            MODELVIEW16_ARB = 0x8730,
-            MODELVIEW21_ARB = 0x8735,
-            MODELVIEW22_ARB = 0x8736,
-            WEIGHT_ARRAY_POINTER_ARB = 0x86AC,
-            WEIGHT_SUM_UNITY_ARB = 0x86A6,
-            MODELVIEW1_ARB = 0x850A,
-            MODELVIEW29_ARB = 0x873D,
-            MODELVIEW11_ARB = 0x872B,
-            MODELVIEW12_ARB = 0x872C,
-            MODELVIEW19_ARB = 0x8733,
-            VERTEX_BLEND_ARB = 0x86A7,
-            MODELVIEW26_ARB = 0x873A,
-            MODELVIEW17_ARB = 0x8731,
-            CURRENT_WEIGHT_ARB = 0x86A8,
-            MODELVIEW27_ARB = 0x873B,
-            MODELVIEW23_ARB = 0x8737,
-            WEIGHT_ARRAY_SIZE_ARB = 0x86AB,
-            MAX_VERTEX_UNITS_ARB = 0x86A4,
-            MODELVIEW7_ARB = 0x8727,
-            MODELVIEW13_ARB = 0x872D,
-            MODELVIEW28_ARB = 0x873C,
-            MODELVIEW25_ARB = 0x8739,
-            WEIGHT_ARRAY_TYPE_ARB = 0x86A9,
-            MODELVIEW8_ARB = 0x8728,
-            WEIGHT_ARRAY_STRIDE_ARB = 0x86AA,
-            MODELVIEW18_ARB = 0x8732,
-            MODELVIEW9_ARB = 0x8729,
-            MODELVIEW24_ARB = 0x8738,
-            MODELVIEW14_ARB = 0x872E,
-            MODELVIEW20_ARB = 0x8734,
-            MODELVIEW31_ARB = 0x873F,
-            MODELVIEW30_ARB = 0x873E,
-            MODELVIEW2_ARB = 0x8722,
-            MODELVIEW3_ARB = 0x8723,
-        }
-
-        public enum AttribMask : uint
-        {
-            POLYGON_BIT = 0x00000008,
-            TRANSFORM_BIT = 0x00001000,
-            COLOR_BUFFER_BIT = 0x00004000,
-            LINE_BIT = 0x00000004,
-            POINT_BIT = 0x00000002,
-            EVAL_BIT = 0x00010000,
-            LIST_BIT = 0x00020000,
-            FOG_BIT = 0x00000080,
-            HINT_BIT = 0x00008000,
-            ENABLE_BIT = 0x00002000,
-            STENCIL_BUFFER_BIT = 0x00000400,
-            TEXTURE_BIT = 0x00040000,
-            ACCUM_BUFFER_BIT = 0x00000200,
-            LIGHTING_BIT = 0x00000040,
-            CURRENT_BIT = 0x00000001,
-            ALL_ATTRIB_BITS = 0xFFFFFFFF,
-            DEPTH_BUFFER_BIT = 0x00000100,
-            POLYGON_STIPPLE_BIT = 0x00000010,
-            SCISSOR_BIT = 0x00080000,
-            VIEWPORT_BIT = 0x00000800,
-            PIXEL_MODE_BIT = 0x00000020,
-        }
-
-        public enum SGIX_pixel_texture : uint
-        {
-            PIXEL_TEX_GEN_SGIX = 0x8139,
-            PIXEL_TEX_GEN_MODE_SGIX = 0x832B,
-        }
-
-        public enum SGIX_framezoom : uint
-        {
-            FRAMEZOOM_FACTOR_SGIX = 0x818C,
-            MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D,
-            FRAMEZOOM_SGIX = 0x818B,
-        }
-
-        public enum TextureGenParameter : uint
-        {
-            EYE_PLANE = 0x2502,
-            OBJECT_LINE_SGIS = SGIS_point_line_texgen.OBJECT_LINE_SGIS,
-            EYE_POINT_SGIS = SGIS_point_line_texgen.EYE_POINT_SGIS,
-            TEXTURE_GEN_MODE = 0x2500,
-            EYE_LINE_SGIS = SGIS_point_line_texgen.EYE_LINE_SGIS,
-            OBJECT_POINT_SGIS = SGIS_point_line_texgen.OBJECT_POINT_SGIS,
-            OBJECT_PLANE = 0x2501,
-        }
-
-        public enum ReadBufferMode : uint
-        {
-            FRONT_RIGHT = DrawBufferMode.FRONT_RIGHT,
-            AUX3 = DrawBufferMode.AUX3,
-            AUX1 = DrawBufferMode.AUX1,
-            LEFT = DrawBufferMode.LEFT,
-            RIGHT = DrawBufferMode.RIGHT,
-            BACK_RIGHT = DrawBufferMode.BACK_RIGHT,
-            AUX2 = DrawBufferMode.AUX2,
-            AUX0 = DrawBufferMode.AUX0,
-            FRONT_LEFT = DrawBufferMode.FRONT_LEFT,
-            BACK = DrawBufferMode.BACK,
-            FRONT = DrawBufferMode.FRONT,
-            BACK_LEFT = DrawBufferMode.BACK_LEFT,
-        }
-
-        public enum FeedBackToken : uint
-        {
-            BITMAP_TOKEN = 0x0704,
-            LINE_TOKEN = 0x0702,
-            PASS_THROUGH_TOKEN = 0x0700,
-            LINE_RESET_TOKEN = 0x0707,
-            POINT_TOKEN = 0x0701,
-            COPY_PIXEL_TOKEN = 0x0706,
-            DRAW_PIXEL_TOKEN = 0x0705,
-            POLYGON_TOKEN = 0x0703,
-        }
-
-        public enum TextureMinFilter : uint
-        {
-            LINEAR = TextureMagFilter.LINEAR,
-            PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX,
-            FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
-            PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX,
-            NEAREST_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_NEAREST_SGIX,
-            LINEAR_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_NEAREST_SGIX,
-            NEAREST_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_LINEAR_SGIX,
-            NEAREST_MIPMAP_LINEAR = 0x2702,
-            NEAREST = TextureMagFilter.NEAREST,
-            NEAREST_MIPMAP_NEAREST = 0x2700,
-            LINEAR_MIPMAP_NEAREST = 0x2701,
-            LINEAR_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_LINEAR_SGIX,
-            LINEAR_MIPMAP_LINEAR = 0x2703,
-            PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX,
-        }
-
-        public enum APPLE_element_array : uint
-        {
-            ELEMENT_ARRAY_POINTER_APPLE = 0x876A,
-            ELEMENT_ARRAY_APPLE = 0x8768,
-            ELEMENT_ARRAY_TYPE_APPLE = 0x8769,
-        }
-
-        public enum VERSION_1_5 : uint
-        {
-            DYNAMIC_READ = 0x88E9,
-            VERTEX_ARRAY_BUFFER_BINDING = 0x8896,
-            STREAM_COPY = 0x88E2,
-            FOG_COORD_ARRAY_STRIDE = VERSION_1_4.FOG_COORDINATE_ARRAY_STRIDE,
-            FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D,
-            READ_WRITE = 0x88BA,
-            SRC1_ALPHA = VERSION_1_3.SOURCE1_ALPHA,
-            TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A,
-            BUFFER_MAP_POINTER = 0x88BD,
-            QUERY_COUNTER_BITS = 0x8864,
-            STATIC_COPY = 0x88E6,
-            STATIC_DRAW = 0x88E4,
-            SRC2_RGB = VERSION_1_3.SOURCE2_RGB,
-            SRC2_ALPHA = VERSION_1_3.SOURCE2_ALPHA,
-            FOG_COORD_ARRAY = VERSION_1_4.FOG_COORDINATE_ARRAY,
-            FOG_COORD_SRC = VERSION_1_4.FOG_COORDINATE_SOURCE,
-            DYNAMIC_COPY = 0x88EA,
-            STATIC_READ = 0x88E5,
-            FOG_COORD_ARRAY_BUFFER_BINDING = VERSION_1_5.FOG_COORDINATE_ARRAY_BUFFER_BINDING,
-            FOG_COORD_ARRAY_POINTER = VERSION_1_4.FOG_COORDINATE_ARRAY_POINTER,
-            EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B,
-            CURRENT_FOG_COORD = VERSION_1_4.CURRENT_FOG_COORDINATE,
-            VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F,
-            READ_ONLY = 0x88B8,
-            SRC0_ALPHA = VERSION_1_3.SOURCE0_ALPHA,
-            ELEMENT_ARRAY_BUFFER = 0x8893,
-            CURRENT_QUERY = 0x8865,
-            FOG_COORD = VERSION_1_4.FOG_COORDINATE,
-            QUERY_RESULT = 0x8866,
-            BUFFER_USAGE = 0x8765,
-            BUFFER_ACCESS = 0x88BB,
-            STREAM_DRAW = 0x88E0,
-            SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C,
-            SRC0_RGB = VERSION_1_3.SOURCE0_RGB,
-            ARRAY_BUFFER_BINDING = 0x8894,
-            QUERY_RESULT_AVAILABLE = 0x8867,
-            WRITE_ONLY = 0x88B9,
-            BUFFER_SIZE = 0x8764,
-            WEIGHT_ARRAY_BUFFER_BINDING = 0x889E,
-            SRC1_RGB = VERSION_1_3.SOURCE1_RGB,
-            SAMPLES_PASSED = 0x8914,
-            DYNAMIC_DRAW = 0x88E8,
-            ARRAY_BUFFER = 0x8892,
-            NORMAL_ARRAY_BUFFER_BINDING = 0x8897,
-            COLOR_ARRAY_BUFFER_BINDING = 0x8898,
-            INDEX_ARRAY_BUFFER_BINDING = 0x8899,
-            BUFFER_MAPPED = 0x88BC,
-            ELEMENT_ARRAY_BUFFER_BINDING = 0x8895,
-            STREAM_READ = 0x88E1,
-            FOG_COORD_ARRAY_TYPE = VERSION_1_4.FOG_COORDINATE_ARRAY_TYPE,
-        }
-
-        public enum ErrorCode : uint
-        {
-            OUT_OF_MEMORY = 0x0505,
-            TEXTURE_TOO_LARGE_EXT = EXT_texture.TEXTURE_TOO_LARGE_EXT,
-            STACK_OVERFLOW = 0x0503,
-            INVALID_ENUM = 0x0500,
-            INVALID_VALUE = 0x0501,
-            TABLE_TOO_LARGE_EXT = EXT_histogram.TABLE_TOO_LARGE_EXT,
-            INVALID_OPERATION = 0x0502,
-            STACK_UNDERFLOW = 0x0504,
-            NO_ERROR = 0,
-        }
-
-        public enum GetPointervPName : uint
-        {
-            FEEDBACK_BUFFER_POINTER = 0x0DF0,
-            EDGE_FLAG_ARRAY_POINTER = 0x8093,
-            TEXTURE_COORD_ARRAY_POINTER = 0x8092,
-            INDEX_ARRAY_POINTER = 0x8091,
-            INSTRUMENT_BUFFER_POINTER_SGIX = SGIX_instruments.INSTRUMENT_BUFFER_POINTER_SGIX,
-            SELECTION_BUFFER_POINTER = 0x0DF3,
-            NORMAL_ARRAY_POINTER = 0x808F,
-            VERTEX_ARRAY_POINTER = 0x808E,
-            COLOR_ARRAY_POINTER = 0x8090,
-        }
-
-        public enum BlendingFactorSrc : uint
-        {
-            ZERO = BlendingFactorDest.ZERO,
-            ONE_MINUS_SRC_ALPHA = BlendingFactorDest.ONE_MINUS_SRC_ALPHA,
-            ONE_MINUS_DST_COLOR = 0x0307,
-            ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT,
-            CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT,
-            DST_ALPHA = BlendingFactorDest.DST_ALPHA,
-            CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT,
-            SRC_ALPHA = BlendingFactorDest.SRC_ALPHA,
-            SRC_ALPHA_SATURATE = 0x0308,
-            ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT,
-            ONE_MINUS_DST_ALPHA = BlendingFactorDest.ONE_MINUS_DST_ALPHA,
-            DST_COLOR = 0x0306,
-            ONE = BlendingFactorDest.ONE,
-        }
-
-        public enum APPLE_vertex_array_object : uint
-        {
-            VERTEX_ARRAY_BINDING_APPLE = 0x85B5,
-        }
-
-        public enum ATI_fragment_shader : uint
-        {
-            REG_16_ATI = 0x8931,
-            CON_12_ATI = 0x894D,
-            REG_14_ATI = 0x892F,
-            CON_14_ATI = 0x894F,
-            HALF_BIT_ATI = 0x00000008,
-            NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973,
-            REG_25_ATI = 0x893A,
-            REG_10_ATI = 0x892B,
-            CON_6_ATI = 0x8947,
-            REG_15_ATI = 0x8930,
-            REG_2_ATI = 0x8923,
-            NUM_FRAGMENT_CONSTANTS_ATI = 0x896F,
-            QUARTER_BIT_ATI = 0x00000010,
-            REG_19_ATI = 0x8934,
-            CON_27_ATI = 0x895C,
-            NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971,
-            FRAGMENT_SHADER_ATI = 0x8920,
-            NUM_PASSES_ATI = 0x8970,
-            REG_28_ATI = 0x893D,
-            CON_1_ATI = 0x8942,
-            REG_3_ATI = 0x8924,
-            CON_9_ATI = 0x894A,
-            CON_4_ATI = 0x8945,
-            CON_18_ATI = 0x8953,
-            REG_27_ATI = 0x893C,
-            REG_22_ATI = 0x8937,
-            REG_21_ATI = 0x8936,
-            SWIZZLE_STR_DR_ATI = 0x8978,
-            REG_20_ATI = 0x8935,
-            CON_21_ATI = 0x8956,
-            MUL_ATI = 0x8964,
-            SATURATE_BIT_ATI = 0x00000040,
-            REG_0_ATI = 0x8921,
-            MOV_ATI = 0x8961,
-            SWIZZLE_STQ_DQ_ATI = 0x8979,
-            SWIZZLE_STQ_ATI = 0x8977,
-            SWIZZLE_STR_ATI = 0x8976,
-            REG_8_ATI = 0x8929,
-            CON_10_ATI = 0x894B,
-            CON_7_ATI = 0x8948,
-            DOT2_ADD_ATI = 0x896C,
-            CON_16_ATI = 0x8951,
-            CON_22_ATI = 0x8957,
-            REG_31_ATI = 0x8940,
-            MAD_ATI = 0x8968,
-            COLOR_ALPHA_PAIRING_ATI = 0x8975,
-            CON_24_ATI = 0x8959,
-            REG_30_ATI = 0x893F,
-            CON_13_ATI = 0x894E,
-            REG_1_ATI = 0x8922,
-            CON_15_ATI = 0x8950,
-            REG_18_ATI = 0x8933,
-            SECONDARY_INTERPOLATOR_ATI = 0x896D,
-            REG_9_ATI = 0x892A,
-            BLUE_BIT_ATI = 0x00000004,
-            CON_2_ATI = 0x8943,
-            LERP_ATI = 0x8969,
-            REG_17_ATI = 0x8932,
-            _4X_BIT_ATI = 0x00000002,
-            REG_12_ATI = 0x892D,
-            REG_11_ATI = 0x892C,
-            CND0_ATI = 0x896B,
-            REG_6_ATI = 0x8927,
-            REG_23_ATI = 0x8938,
-            CON_29_ATI = 0x895E,
-            SWIZZLE_STRQ_DQ_ATI = 0x897B,
-            NEGATE_BIT_ATI = 0x00000004,
-            CON_31_ATI = 0x8960,
-            CON_5_ATI = 0x8946,
-            _8X_BIT_ATI = 0x00000004,
-            CON_8_ATI = 0x8949,
-            COMP_BIT_ATI = 0x00000002,
-            REG_26_ATI = 0x893B,
-            CON_26_ATI = 0x895B,
-            REG_24_ATI = 0x8939,
-            BIAS_BIT_ATI = 0x00000008,
-            RED_BIT_ATI = 0x00000001,
-            CON_28_ATI = 0x895D,
-            CND_ATI = 0x896A,
-            CON_17_ATI = 0x8952,
-            REG_7_ATI = 0x8928,
-            CON_19_ATI = 0x8954,
-            EIGHTH_BIT_ATI = 0x00000020,
-            CON_30_ATI = 0x895F,
-            NUM_LOOPBACK_COMPONENTS_ATI = 0x8974,
-            REG_4_ATI = 0x8925,
-            CON_0_ATI = 0x8941,
-            ADD_ATI = 0x8963,
-            GREEN_BIT_ATI = 0x00000002,
-            DOT3_ATI = 0x8966,
-            CON_20_ATI = 0x8955,
-            REG_29_ATI = 0x893E,
-            CON_11_ATI = 0x894C,
-            CON_3_ATI = 0x8944,
-            NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972,
-            SUB_ATI = 0x8965,
-            _2X_BIT_ATI = 0x00000001,
-            NUM_FRAGMENT_REGISTERS_ATI = 0x896E,
-            REG_13_ATI = 0x892E,
-            CON_23_ATI = 0x8958,
-            DOT4_ATI = 0x8967,
-            SWIZZLE_STRQ_ATI = 0x897A,
-            REG_5_ATI = 0x8926,
-            CON_25_ATI = 0x895A,
-        }
-
-        public enum SGIX_list_priority : uint
-        {
-            LIST_PRIORITY_SGIX = 0x8182,
-        }
-
-        public enum FeedbackType : uint
-        {
-            _3D_COLOR_TEXTURE = 0x0603,
-            _4D_COLOR_TEXTURE = 0x0604,
-            _3D_COLOR = 0x0602,
-            _2D = 0x0600,
-            _3D = 0x0601,
-        }
-
-        public enum GREMEDY_string_marker : uint
-        {
-        }
-
-        public enum ARB_point_sprite : uint
-        {
-            POINT_SPRITE_ARB = 0x8861,
-            COORD_REPLACE_ARB = 0x8862,
-        }
-
-        public enum INGR_color_clamp : uint
-        {
-            BLUE_MIN_CLAMP_INGR = 0x8562,
-            RED_MAX_CLAMP_INGR = 0x8564,
-            ALPHA_MAX_CLAMP_INGR = 0x8567,
-            ALPHA_MIN_CLAMP_INGR = 0x8563,
-            GREEN_MAX_CLAMP_INGR = 0x8565,
-            BLUE_MAX_CLAMP_INGR = 0x8566,
-            GREEN_MIN_CLAMP_INGR = 0x8561,
-            RED_MIN_CLAMP_INGR = 0x8560,
-        }
-
-        public enum PGI_misc_hints : uint
-        {
-            FULL_STIPPLE_HINT_PGI = 0x1A219,
-            BACK_NORMALS_HINT_PGI = 0x1A223,
-            ALLOW_DRAW_MEM_HINT_PGI = 0x1A211,
-            ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F,
-            ALWAYS_FAST_HINT_PGI = 0x1A20C,
-            NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202,
-            CONSERVE_MEMORY_HINT_PGI = 0x1A1FD,
-            PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8,
-            STRICT_LIGHTING_HINT_PGI = 0x1A217,
-            CLIP_FAR_HINT_PGI = 0x1A221,
-            CLIP_NEAR_HINT_PGI = 0x1A220,
-            STRICT_SCISSOR_HINT_PGI = 0x1A218,
-            ALLOW_DRAW_FRG_HINT_PGI = 0x1A210,
-            ALWAYS_SOFT_HINT_PGI = 0x1A20D,
-            NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203,
-            ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E,
-            NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204,
-            RECLAIM_MEMORY_HINT_PGI = 0x1A1FE,
-            STRICT_DEPTHFUNC_HINT_PGI = 0x1A216,
-            WIDE_LINE_HINT_PGI = 0x1A222,
-        }
-
-        public enum SGIS_pixel_texture : uint
-        {
-            PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354,
-            PIXEL_TEXTURE_SGIS = 0x8353,
-            PIXEL_GROUP_COLOR_SGIS = 0x8356,
-            PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355,
-        }
-
-        public enum VERSION_2_1 : uint
-        {
-            FLOAT_MAT3x2 = 0x8B67,
-            SRGB8 = 0x8C41,
-            FLOAT_MAT3x4 = 0x8B68,
-            COMPRESSED_SRGB_ALPHA = 0x8C49,
-            FLOAT_MAT4x3 = 0x8B6A,
-            SLUMINANCE_ALPHA = 0x8C44,
-            PIXEL_UNPACK_BUFFER = 0x88EC,
-            SRGB_ALPHA = 0x8C42,
-            COMPRESSED_SLUMINANCE = 0x8C4A,
-            FLOAT_MAT4x2 = 0x8B69,
-            SRGB8_ALPHA8 = 0x8C43,
-            COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B,
-            PIXEL_UNPACK_BUFFER_BINDING = 0x88EF,
-            PIXEL_PACK_BUFFER = 0x88EB,
-            FLOAT_MAT2x3 = 0x8B65,
-            COMPRESSED_SRGB = 0x8C48,
-            PIXEL_PACK_BUFFER_BINDING = 0x88ED,
-            SRGB = 0x8C40,
-            SLUMINANCE8 = 0x8C47,
-            SLUMINANCE = 0x8C46,
-            FLOAT_MAT2x4 = 0x8B66,
-            SLUMINANCE8_ALPHA8 = 0x8C45,
-            CURRENT_RASTER_SECONDARY_COLOR = 0x845F,
-        }
-
-        public enum APPLE_ycbcr_422 : uint
-        {
-            UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB,
-            YCBCR_422_APPLE = 0x85B9,
-            UNSIGNED_SHORT_8_8_APPLE = 0x85BA,
-        }
-
-        public enum ARB_vertex_shader : uint
-        {
-            MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D,
-            VERTEX_SHADER_ARB = 0x8B31,
-            OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89,
-            MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C,
-            MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A,
-            MAX_VARYING_FLOATS_ARB = 0x8B4B,
-            OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A,
-        }
-
-        public enum EXT_shadow_funcs : uint
-        {
-        }
-
-        public enum EXT_blend_func_separate : uint
-        {
-            BLEND_SRC_ALPHA_EXT = 0x80CB,
-            BLEND_DST_RGB_EXT = 0x80C8,
-            BLEND_DST_ALPHA_EXT = 0x80CA,
-            BLEND_SRC_RGB_EXT = 0x80C9,
-        }
-
-        public enum SGIS_texture_lod : uint
-        {
-            TEXTURE_MAX_LOD_SGIS = 0x813B,
-            TEXTURE_MAX_LEVEL = 0x813D,
-            TEXTURE_BASE_LEVEL_SGIS = 0x813C,
-            TEXTURE_MIN_LOD_SGIS = 0x813A,
-            TEXTURE_MIN_LOD = 0x813A,
-            TEXTURE_MAX_LOD = 0x813B,
-            TEXTURE_BASE_LEVEL = 0x813C,
-            TEXTURE_MAX_LEVEL_SGIS = 0x813D,
-        }
-
-        public enum SGIX_depth_texture : uint
-        {
-            DEPTH_COMPONENT16_SGIX = 0x81A5,
-            DEPTH_COMPONENT32_SGIX = 0x81A7,
-            DEPTH_COMPONENT16 = 0x81A5,
-            DEPTH_COMPONENT24 = 0x81A6,
-            DEPTH_COMPONENT24_SGIX = 0x81A6,
-            DEPTH_COMPONENT32 = 0x81A7,
-        }
-
-        public enum EXT_texture_perturb_normal : uint
-        {
-            TEXTURE_NORMAL_EXT = 0x85AF,
-            PERTURB_EXT = 0x85AE,
-        }
-
-        public enum EXT_light_texture : uint
-        {
-            ATTENUATION_EXT = 0x834D,
-            FRAGMENT_DEPTH_EXT = EXT_fog_coord.FRAGMENT_DEPTH_EXT,
-            TEXTURE_LIGHT_EXT = 0x8350,
-            FRAGMENT_NORMAL_EXT = 0x834A,
-            FRAGMENT_MATERIAL_EXT = 0x8349,
-            TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352,
-            TEXTURE_MATERIAL_FACE_EXT = 0x8351,
-            SHADOW_ATTENUATION_EXT = 0x834E,
-            FRAGMENT_COLOR_EXT = 0x834C,
-            TEXTURE_APPLICATION_MODE_EXT = 0x834F,
-        }
-
-        public enum Boolean : uint
-        {
-            TRUE = 1,
-            FALSE = 0,
-        }
-
-        public enum ARB_texture_rectangle : uint
-        {
-            TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6,
-            TEXTURE_RECTANGLE_ARB = 0x84F5,
-            MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8,
-            PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7,
-        }
-
-        public enum SGIX_reference_plane : uint
-        {
-            REFERENCE_PLANE_EQUATION_SGIX = 0x817E,
-            REFERENCE_PLANE_SGIX = 0x817D,
-        }
-
-        public enum StencilOp : uint
-        {
-            REPLACE = 0x1E01,
-            DECR = 0x1E03,
-            INVERT = LogicOp.INVERT,
-            INCR = 0x1E02,
-            KEEP = 0x1E00,
-            ZERO = BlendingFactorDest.ZERO,
-        }
-
-        public enum EXT_multisample : uint
-        {
-            SAMPLE_MASK_EXT = 0x80A0,
-            MULTISAMPLE_EXT = 0x809D,
-            _4PASS_3_EXT = 0x80A7,
-            _4PASS_2_EXT = 0x80A6,
-            SAMPLE_PATTERN_EXT = 0x80AC,
-            SAMPLE_ALPHA_TO_MASK_EXT = 0x809E,
-            _2PASS_1_EXT = 0x80A3,
-            SAMPLES_EXT = 0x80A9,
-            SAMPLE_MASK_INVERT_EXT = 0x80AB,
-            SAMPLE_BUFFERS_EXT = 0x80A8,
-            MULTISAMPLE_BIT_EXT = 0x20000000,
-            _4PASS_1_EXT = 0x80A5,
-            SAMPLE_MASK_VALUE_EXT = 0x80AA,
-            _2PASS_0_EXT = 0x80A2,
-            _1PASS_EXT = 0x80A1,
-            _4PASS_0_EXT = 0x80A4,
-            SAMPLE_ALPHA_TO_ONE_EXT = 0x809F,
-        }
-
-        public enum HP_texture_lighting : uint
-        {
-            TEXTURE_LIGHTING_MODE_HP = 0x8167,
-            TEXTURE_PRE_SPECULAR_HP = 0x8169,
-            TEXTURE_POST_SPECULAR_HP = 0x8168,
-        }
-
-        public enum ARB_shadow : uint
-        {
-            TEXTURE_COMPARE_MODE_ARB = 0x884C,
-            TEXTURE_COMPARE_FUNC_ARB = 0x884D,
-            COMPARE_R_TO_TEXTURE_ARB = 0x884E,
-        }
-
-        public enum SGIS_texture4D : uint
-        {
-            TEXTURE_4D_BINDING_SGIS = 0x814F,
-            PACK_IMAGE_DEPTH_SGIS = 0x8131,
-            MAX_4D_TEXTURE_SIZE_SGIS = 0x8138,
-            PACK_SKIP_VOLUMES_SGIS = 0x8130,
-            TEXTURE_4D_SGIS = 0x8134,
-            PROXY_TEXTURE_4D_SGIS = 0x8135,
-            UNPACK_IMAGE_DEPTH_SGIS = 0x8133,
-            UNPACK_SKIP_VOLUMES_SGIS = 0x8132,
-            TEXTURE_4DSIZE_SGIS = 0x8136,
-            TEXTURE_WRAP_Q_SGIS = 0x8137,
-        }
-
-        public enum ColorPointerType : uint
-        {
-            UNSIGNED_INT = DataType.UNSIGNED_INT,
-            FLOAT = DataType.FLOAT,
-            UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
-            SHORT = DataType.SHORT,
-            BYTE = DataType.BYTE,
-            INT = DataType.INT,
-            UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
-            DOUBLE = DataType.DOUBLE,
-        }
-
-        public enum VertexPointerType : uint
-        {
-            DOUBLE = DataType.DOUBLE,
-            INT = DataType.INT,
-            SHORT = DataType.SHORT,
-            FLOAT = DataType.FLOAT,
-        }
-
-        public enum EXT_shared_texture_palette : uint
-        {
-            SHARED_TEXTURE_PALETTE_EXT = 0x81FB,
-        }
-
-        public enum ATI_vertex_array_object : uint
-        {
-            ARRAY_OBJECT_BUFFER_ATI = 0x8766,
-            PRESERVE_ATI = 0x8762,
-            DISCARD_ATI = 0x8763,
-            STATIC_ATI = 0x8760,
-            ARRAY_OBJECT_OFFSET_ATI = 0x8767,
-            OBJECT_BUFFER_SIZE_ATI = 0x8764,
-            OBJECT_BUFFER_USAGE_ATI = 0x8765,
-            DYNAMIC_ATI = 0x8761,
-        }
-
-        public enum PixelTexGenParameterNameSGIS : uint
-        {
-            PIXEL_FRAGMENT_RGB_SOURCE_SGIS = SGIS_pixel_texture.PIXEL_FRAGMENT_RGB_SOURCE_SGIS,
-            PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = SGIS_pixel_texture.PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS,
-        }
-
-        public enum EXT_blend_equation_separate : uint
-        {
-            BLEND_EQUATION_RGB_EXT = ARB_imaging.BLEND_EQUATION,
-            BLEND_EQUATION_ALPHA_EXT = 0x883D,
-        }
-
-        public enum PixelStoreResampleMode : uint
-        {
-            RESAMPLE_DECIMATE_SGIX = SGIX_resample.RESAMPLE_DECIMATE_SGIX,
-            RESAMPLE_REPLICATE_SGIX = SGIX_resample.RESAMPLE_REPLICATE_SGIX,
-            RESAMPLE_ZERO_FILL_SGIX = SGIX_resample.RESAMPLE_ZERO_FILL_SGIX,
-        }
-
-        public enum SGIX_fragment_lighting : uint
-        {
-            FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402,
-            FRAGMENT_LIGHT1_SGIX = 0x840D,
-            LIGHT_ENV_MODE_SGIX = 0x8407,
-            FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408,
-            CURRENT_RASTER_NORMAL_SGIX = 0x8406,
-            FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403,
-            FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B,
-            MAX_FRAGMENT_LIGHTS_SGIX = 0x8404,
-            FRAGMENT_LIGHT4_SGIX = 0x8410,
-            FRAGMENT_LIGHT5_SGIX = 0x8411,
-            FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A,
-            FRAGMENT_LIGHTING_SGIX = 0x8400,
-            FRAGMENT_LIGHT6_SGIX = 0x8412,
-            MAX_ACTIVE_LIGHTS_SGIX = 0x8405,
-            FRAGMENT_LIGHT2_SGIX = 0x840E,
-            FRAGMENT_LIGHT0_SGIX = 0x840C,
-            FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401,
-            FRAGMENT_LIGHT3_SGIX = 0x840F,
-            FRAGMENT_LIGHT7_SGIX = 0x8413,
-            FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409,
-        }
-
-        public enum NV_depth_clamp : uint
-        {
-            DEPTH_CLAMP_NV = 0x864F,
-        }
-
-        public enum EXT_blend_subtract : uint
-        {
-            FUNC_SUBTRACT = 0x800A,
-            FUNC_REVERSE_SUBTRACT = 0x800B,
-            FUNC_REVERSE_SUBTRACT_EXT = 0x800B,
-            FUNC_SUBTRACT_EXT = 0x800A,
-        }
-
-        public enum ARB_vertex_program : uint
-        {
-            VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A,
-            MATRIX9_ARB = 0x88C9,
-            MATRIX24_ARB = 0x88D8,
-            MATRIX25_ARB = 0x88D9,
-            TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7,
-            MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB,
-            MATRIX22_ARB = 0x88D6,
-            MAX_PROGRAM_MATRICES_ARB = 0x862F,
-            PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA,
-            PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2,
-            MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3,
-            PROGRAM_FORMAT_ARB = 0x8876,
-            MATRIX8_ARB = 0x88C8,
-            MAX_PROGRAM_PARAMETERS_ARB = 0x88A9,
-            MATRIX13_ARB = 0x88CD,
-            MATRIX31_ARB = 0x88DF,
-            MATRIX6_ARB = 0x88C6,
-            MATRIX27_ARB = 0x88DB,
-            MATRIX7_ARB = 0x88C7,
-            PROGRAM_ERROR_STRING_ARB = 0x8874,
-            PROGRAM_PARAMETERS_ARB = 0x88A8,
-            PROGRAM_BINDING_ARB = 0x8677,
-            VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642,
-            PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6,
-            CURRENT_VERTEX_ATTRIB_ARB = 0x8626,
-            MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4,
-            MATRIX12_ARB = 0x88CC,
-            PROGRAM_STRING_ARB = 0x8628,
-            PROGRAM_INSTRUCTIONS_ARB = 0x88A0,
-            MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5,
-            VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623,
-            MATRIX26_ARB = 0x88DA,
-            MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3,
-            MATRIX4_ARB = 0x88C4,
-            CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640,
-            VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643,
-            VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625,
-            PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0,
-            MATRIX2_ARB = 0x88C2,
-            MATRIX5_ARB = 0x88C5,
-            PROGRAM_ATTRIBS_ARB = 0x88AC,
-            MATRIX14_ARB = 0x88CE,
-            VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624,
-            MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1,
-            MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E,
-            MATRIX3_ARB = 0x88C3,
-            PROGRAM_TEMPORARIES_ARB = 0x88A4,
-            MATRIX28_ARB = 0x88DC,
-            MATRIX29_ARB = 0x88DD,
-            MAX_VERTEX_ATTRIBS_ARB = 0x8869,
-            MATRIX20_ARB = 0x88D4,
-            MATRIX21_ARB = 0x88D5,
-            MAX_PROGRAM_ATTRIBS_ARB = 0x88AD,
-            PROGRAM_ERROR_POSITION_ARB = 0x864B,
-            PROGRAM_FORMAT_ASCII_ARB = 0x8875,
-            MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5,
-            PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2,
-            VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622,
-            VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645,
-            MATRIX30_ARB = 0x88DE,
-            MATRIX15_ARB = 0x88CF,
-            VERTEX_PROGRAM_ARB = 0x8620,
-            MATRIX0_ARB = 0x88C0,
-            MATRIX17_ARB = 0x88D1,
-            PROGRAM_LENGTH_ARB = 0x8627,
-            COLOR_SUM_ARB = 0x8458,
-            MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF,
-            MATRIX1_ARB = 0x88C1,
-            PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6,
-            MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1,
-            MATRIX23_ARB = 0x88D7,
-            MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7,
-            PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE,
-            CURRENT_MATRIX_ARB = 0x8641,
-            MATRIX18_ARB = 0x88D2,
-            MATRIX19_ARB = 0x88D3,
-            MATRIX10_ARB = 0x88CA,
-            MATRIX11_ARB = 0x88CB,
-            MATRIX16_ARB = 0x88D0,
-        }
-
-        public enum SUN_vertex : uint
-        {
-        }
-
-        public enum EXT_secondary_color : uint
-        {
-            SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A,
-            SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D,
-            SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C,
-            SECONDARY_COLOR_ARRAY_EXT = 0x845E,
-            COLOR_SUM_EXT = 0x8458,
-            SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B,
-            CURRENT_SECONDARY_COLOR_EXT = 0x8459,
-        }
-
-        public enum SGIX_scalebias_hint : uint
-        {
-            SCALEBIAS_HINT_SGIX = 0x8322,
-        }
-
-        public enum ListNameType : uint
-        {
-            UNSIGNED_INT = DataType.UNSIGNED_INT,
-            _4_BYTES = DataType._4_BYTES,
-            FLOAT = DataType.FLOAT,
-            UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
-            SHORT = DataType.SHORT,
-            BYTE = DataType.BYTE,
-            _3_BYTES = DataType._3_BYTES,
-            INT = DataType.INT,
-            UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
-            _2_BYTES = DataType._2_BYTES,
-        }
-
-        public enum RenderingMode : uint
-        {
-            SELECT = 0x1C02,
-            FEEDBACK = 0x1C01,
-            RENDER = 0x1C00,
-        }
-
-        public enum EXT_texture_lod_bias : uint
-        {
-            MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD,
-            TEXTURE_FILTER_CONTROL_EXT = 0x8500,
-            TEXTURE_LOD_BIAS_EXT = 0x8501,
-        }
-
-        public enum ARB_depth_texture : uint
-        {
-            DEPTH_TEXTURE_MODE_ARB = 0x884B,
-            DEPTH_COMPONENT16_ARB = 0x81A5,
-            DEPTH_COMPONENT24_ARB = 0x81A6,
-            DEPTH_COMPONENT32_ARB = 0x81A7,
-            TEXTURE_DEPTH_SIZE_ARB = 0x884A,
-        }
-
-        public enum ARB_multisample : uint
-        {
-            SAMPLE_COVERAGE_VALUE_ARB = 0x80AA,
-            SAMPLES_ARB = 0x80A9,
-            SAMPLE_BUFFERS = 0x80A8,
-            SAMPLE_COVERAGE = 0x80A0,
-            MULTISAMPLE_ARB = 0x809D,
-            SAMPLE_ALPHA_TO_COVERAGE = 0x809E,
-            SAMPLE_BUFFERS_ARB = 0x80A8,
-            SAMPLE_COVERAGE_ARB = 0x80A0,
-            SAMPLE_COVERAGE_INVERT_ARB = 0x80AB,
-            SAMPLE_COVERAGE_INVERT = 0x80AB,
-            MULTISAMPLE = 0x809D,
-            SAMPLE_ALPHA_TO_ONE_ARB = 0x809F,
-            SAMPLE_ALPHA_TO_ONE = 0x809F,
-            SAMPLES = 0x80A9,
-            SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E,
-            MULTISAMPLE_BIT_ARB = 0x20000000,
-            SAMPLE_COVERAGE_VALUE = 0x80AA,
-        }
-
-        public enum ConvolutionTargetEXT : uint
-        {
-            CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
-            CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
-        }
-
-        public enum EXT_stencil_wrap : uint
-        {
-            DECR_WRAP_EXT = 0x8508,
-            INCR_WRAP_EXT = 0x8507,
-        }
-
-        public enum SGIS_fog_function : uint
-        {
-            FOG_FUNC_POINTS_SGIS = 0x812B,
-            MAX_FOG_FUNC_POINTS_SGIS = 0x812C,
-            FOG_FUNC_SGIS = 0x812A,
-        }
-
-        public enum SGIX_convolution_accuracy : uint
-        {
-            CONVOLUTION_HINT_SGIX = 0x8316,
-        }
-
-        public enum TextureGenMode : uint
-        {
-            EYE_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_LINE_SGIS,
-            EYE_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_POINT_SGIS,
-            OBJECT_LINEAR = 0x2401,
-            OBJECT_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_LINE_SGIS,
-            OBJECT_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_POINT_SGIS,
-            EYE_LINEAR = 0x2400,
-            SPHERE_MAP = 0x2402,
-        }
-
-        public enum APPLE_client_storage : uint
-        {
-            UNPACK_CLIENT_STORAGE_APPLE = 0x85B2,
-        }
-
-        public enum SUN_slice_accum : uint
-        {
-            SLICE_ACCUM_SUN = 0x85CC,
-        }
-
-        public enum SGIX_polynomial_ffd : uint
-        {
-            MAX_DEFORMATION_ORDER_SGIX = 0x8197,
-            GEOMETRY_DEFORMATION_SGIX = 0x8194,
-            TEXTURE_DEFORMATION_SGIX = 0x8195,
-            DEFORMATIONS_MASK_SGIX = 0x8196,
-        }
-
-        public enum ARB_point_parameters : uint
-        {
-            POINT_DISTANCE_ATTENUATION_ARB = 0x8129,
-            POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128,
-            POINT_SIZE_MIN_ARB = 0x8126,
-            POINT_SIZE_MAX_ARB = 0x8127,
-        }
-
-        public enum ARB_window_pos : uint
-        {
-        }
-
-        public enum ATI_map_object_buffer : uint
-        {
-        }
-
-        public enum OES_read_format : uint
-        {
-            IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A,
-            IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B,
-        }
-
-        public enum GetPName : uint
-        {
-            FRAGMENT_COLOR_MATERIAL_FACE_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_FACE_SGIX,
-            POLYGON_MODE = 0x0B40,
-            STENCIL_FUNC = 0x0B92,
-            FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX,
-            HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
-            CULL_FACE_MODE = 0x0B45,
-            PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX,
-            POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_RANGE_SGIX,
-            CURRENT_RASTER_DISTANCE = 0x0B09,
-            PIXEL_TILE_BEST_ALIGNMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_BEST_ALIGNMENT_SGIX,
-            POINT_SIZE = 0x0B11,
-            MODELVIEW_STACK_DEPTH = 0x0BA3,
-            TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
-            SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS,
-            PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
-            ALPHA_BIAS = 0x0D1D,
-            MAP1_GRID_DOMAIN = 0x0DD0,
-            PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT,
-            MAP2_VERTEX_4 = 0x0DB8,
-            POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT,
-            MAP2_VERTEX_3 = 0x0DB7,
-            DEPTH_RANGE = 0x0B70,
-            POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI,
-            MAX_ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_DRAW_PIXELS_SGIX,
-            PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
-            UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX,
-            CURRENT_RASTER_INDEX = 0x0B05,
-            LIGHT3 = LightName.LIGHT3,
-            UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT,
-            INDEX_ARRAY_COUNT_EXT = EXT_vertex_array.INDEX_ARRAY_COUNT_EXT,
-            LIST_INDEX = 0x0B33,
-            FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX,
-            DEPTH_CLEAR_VALUE = 0x0B73,
-            CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1,
-            DETAIL_TEXTURE_2D_BINDING_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_BINDING_SGIS,
-            STENCIL_VALUE_MASK = 0x0B93,
-            GREEN_BITS = 0x0D53,
-            COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.COLOR_MATRIX_STACK_DEPTH_SGI,
-            POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT,
-            FOG_END = 0x0B64,
-            CLIP_PLANE0 = ClipPlaneName.CLIP_PLANE0,
-            MAX_MODELVIEW_STACK_DEPTH = 0x0D36,
-            LINE_SMOOTH_HINT = 0x0C52,
-            POLYGON_OFFSET_FACTOR = 0x8038,
-            MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS,
-            FOG_MODE = 0x0B65,
-            POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT,
-            PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS,
-            LIST_BASE = 0x0B32,
-            TEXTURE_STACK_DEPTH = 0x0BA5,
-            SCISSOR_TEST = 0x0C11,
-            CURRENT_NORMAL = 0x0B02,
-            CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX,
-            PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
-            INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX,
-            EDGE_FLAG_ARRAY = 0x8079,
-            MAP1_COLOR_4 = 0x0D90,
-            TEXTURE_MATRIX = 0x0BA8,
-            LIGHT4 = LightName.LIGHT4,
-            MAX_3D_TEXTURE_SIZE_EXT = EXT_texture3D.MAX_3D_TEXTURE_SIZE_EXT,
-            PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
-            SELECTION_BUFFER_SIZE = 0x0DF4,
-            MAP2_TEXTURE_COORD_3 = 0x0DB5,
-            SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX,
-            ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX,
-            MAX_FRAGMENT_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_FRAGMENT_LIGHTS_SGIX,
-            PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX,
-            LIGHT_MODEL_AMBIENT = 0x0B53,
-            PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX,
-            ZOOM_X = 0x0D16,
-            PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS,
-            CLIP_PLANE3 = ClipPlaneName.CLIP_PLANE3,
-            COLOR_MATERIAL_FACE = 0x0B55,
-            SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT,
-            SMOOTH_POINT_SIZE_RANGE = VERSION_1_2.SMOOTH_POINT_SIZE_RANGE,
-            ATTRIB_STACK_DEPTH = 0x0BB0,
-            MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B,
-            MAP1_GRID_SEGMENTS = 0x0DD1,
-            FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
-            BLUE_SCALE = 0x0D1A,
-            POINT_SMOOTH = 0x0B10,
-            MAX_PROJECTION_STACK_DEPTH = 0x0D38,
-            INDEX_WRITEMASK = 0x0C21,
-            TEXTURE_BINDING_3D = 0x806A,
-            MAP1_TEXTURE_COORD_4 = 0x0D96,
-            TEXTURE_BINDING_1D = 0x8068,
-            UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT,
-            GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS,
-            POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI,
-            NORMAL_ARRAY_STRIDE = 0x807F,
-            FOG = 0x0B60,
-            CURRENT_RASTER_POSITION_VALID = 0x0B08,
-            COLOR_ARRAY_TYPE = 0x8082,
-            POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI,
-            CLIP_PLANE5 = ClipPlaneName.CLIP_PLANE5,
-            PACK_SKIP_PIXELS = 0x0D04,
-            ALPHA_SCALE = 0x0D1C,
-            SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS,
-            STEREO = 0x0C33,
-            READ_BUFFER = 0x0C02,
-            MAX_4D_TEXTURE_SIZE_SGIS = SGIS_texture4D.MAX_4D_TEXTURE_SIZE_SGIS,
-            RENDER_MODE = 0x0C40,
-            POINT_SIZE_RANGE = 0x0B12,
-            LIST_MODE = 0x0B30,
-            FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX,
-            LIGHTING = 0x0B50,
-            ACCUM_CLEAR_VALUE = 0x0B80,
-            UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX,
-            TEXTURE_GEN_Q = 0x0C63,
-            MAP2_TEXTURE_COORD_2 = 0x0DB4,
-            TEXTURE_GEN_T = 0x0C61,
-            ALIASED_LINE_WIDTH_RANGE = VERSION_1_2.ALIASED_LINE_WIDTH_RANGE,
-            RED_BITS = 0x0D52,
-            COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
-            SCISSOR_BOX = 0x0C10,
-            PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX,
-            INDEX_ARRAY_TYPE = 0x8085,
-            LIGHT6 = LightName.LIGHT6,
-            MAX_COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.MAX_COLOR_MATRIX_STACK_DEPTH_SGI,
-            SAMPLES_SGIS = SGIS_multisample.SAMPLES_SGIS,
-            BLEND = 0x0BE2,
-            STENCIL_CLEAR_VALUE = 0x0B91,
-            FEEDBACK_BUFFER_SIZE = 0x0DF1,
-            SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
-            LINE_STIPPLE_REPEAT = 0x0B26,
-            INDEX_MODE = 0x0C30,
-            TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
-            SMOOTH_LINE_WIDTH_RANGE = VERSION_1_2.SMOOTH_LINE_WIDTH_RANGE,
-            STENCIL_REF = 0x0B97,
-            SMOOTH_POINT_SIZE_GRANULARITY = VERSION_1_2.SMOOTH_POINT_SIZE_GRANULARITY,
-            BLUE_BITS = 0x0D54,
-            FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX,
-            COLOR_LOGIC_OP = 0x0BF2,
-            POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
-            BLEND_COLOR_EXT = EXT_blend_color.BLEND_COLOR_EXT,
-            PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS,
-            MAX_FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.MAX_FRAMEZOOM_FACTOR_SGIX,
-            MATRIX_MODE = 0x0BA0,
-            DEPTH_FUNC = 0x0B74,
-            POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI,
-            PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX,
-            FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX,
-            ACCUM_RED_BITS = 0x0D58,
-            POLYGON_OFFSET_UNITS = 0x2A00,
-            TEXTURE_2D = 0x0DE1,
-            EDGE_FLAG_ARRAY_COUNT_EXT = EXT_vertex_array.EDGE_FLAG_ARRAY_COUNT_EXT,
-            TEXTURE_COORD_ARRAY_TYPE = 0x8089,
-            CURRENT_INDEX = 0x0B01,
-            PACK_SWAP_BYTES = 0x0D00,
-            INDEX_ARRAY = 0x8077,
-            GREEN_BIAS = 0x0D19,
-            SAMPLE_MASK_INVERT_SGIS = SGIS_multisample.SAMPLE_MASK_INVERT_SGIS,
-            AUTO_NORMAL = 0x0D80,
-            POINT_SIZE_GRANULARITY = 0x0B13,
-            POLYGON_SMOOTH = 0x0B41,
-            FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX,
-            ALPHA_BITS = 0x0D55,
-            UNPACK_ALIGNMENT = 0x0CF5,
-            SAMPLE_PATTERN_SGIS = SGIS_multisample.SAMPLE_PATTERN_SGIS,
-            INDEX_ARRAY_STRIDE = 0x8086,
-            POLYGON_OFFSET_BIAS_EXT = EXT_polygon_offset.POLYGON_OFFSET_BIAS_EXT,
-            RED_SCALE = 0x0D14,
-            UNPACK_SKIP_ROWS = 0x0CF3,
-            INDEX_LOGIC_OP = 0x0BF1,
-            MAP2_COLOR_4 = 0x0DB0,
-            VERTEX_ARRAY_COUNT_EXT = EXT_vertex_array.VERTEX_ARRAY_COUNT_EXT,
-            MAP1_NORMAL = 0x0D92,
-            MAP1_TEXTURE_COORD_2 = 0x0D94,
-            PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
-            ACCUM_BLUE_BITS = 0x0D5A,
-            ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX,
-            COLOR_WRITEMASK = 0x0C23,
-            NAME_STACK_DEPTH = 0x0D70,
-            POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT,
-            MAX_NAME_STACK_DEPTH = 0x0D37,
-            CLIP_PLANE4 = ClipPlaneName.CLIP_PLANE4,
-            FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX,
-            PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
-            PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT,
-            LIGHT0 = LightName.LIGHT0,
-            PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
-            FOG_HINT = 0x0C54,
-            PROJECTION_STACK_DEPTH = 0x0BA4,
-            PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX,
-            RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT,
-            MAP2_GRID_DOMAIN = 0x0DD2,
-            ALPHA_TEST_FUNC = 0x0BC1,
-            MAX_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_DEPTH_SGIX,
-            UNPACK_SKIP_PIXELS = 0x0CF4,
-            NORMAL_ARRAY_TYPE = 0x807E,
-            FOG_FUNC_POINTS_SGIS = SGIS_fog_function.FOG_FUNC_POINTS_SGIS,
-            GREEN_SCALE = 0x0D18,
-            PACK_ROW_LENGTH = 0x0D02,
-            CURRENT_COLOR = 0x0B00,
-            MAX_FOG_FUNC_POINTS_SGIS = SGIS_fog_function.MAX_FOG_FUNC_POINTS_SGIS,
-            POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT,
-            COLOR_ARRAY_SIZE = 0x8081,
-            MAP2_TEXTURE_COORD_4 = 0x0DB6,
-            COLOR_MATERIAL_PARAMETER = 0x0B56,
-            FOG_DENSITY = 0x0B62,
-            FOG_START = 0x0B63,
-            FRONT_FACE = 0x0B46,
-            POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI,
-            SPRITE_AXIS_SGIX = SGIX_sprite.SPRITE_AXIS_SGIX,
-            UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS,
-            MAP1_VERTEX_4 = 0x0D98,
-            ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX,
-            LIGHT5 = LightName.LIGHT5,
-            MAP1_VERTEX_3 = 0x0D97,
-            AUX_BUFFERS = 0x0C00,
-            UNPACK_LSB_FIRST = 0x0CF1,
-            VERTEX_ARRAY_SIZE = 0x807A,
-            COLOR_MATERIAL = 0x0B57,
-            MAP1_TEXTURE_COORD_3 = 0x0D95,
-            LINE_STIPPLE_PATTERN = 0x0B25,
-            PERSPECTIVE_CORRECTION_HINT = 0x0C50,
-            MAX_ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.MAX_ASYNC_TEX_IMAGE_SGIX,
-            PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
-            UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT,
-            SPRITE_TRANSLATION_SGIX = SGIX_sprite.SPRITE_TRANSLATION_SGIX,
-            PIXEL_TILE_CACHE_INCREMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_INCREMENT_SGIX,
-            SAMPLE_MASK_VALUE_SGIS = SGIS_multisample.SAMPLE_MASK_VALUE_SGIS,
-            LOGIC_OP = 0x0BF1,
-            PACK_LSB_FIRST = 0x0D01,
-            LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX,
-            MAP2_INDEX = 0x0DB1,
-            UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS,
-            FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX,
-            COLOR_CLEAR_VALUE = 0x0C22,
-            MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX,
-            PROJECTION_MATRIX = 0x0BA7,
-            POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT,
-            ACCUM_ALPHA_BITS = 0x0D5B,
-            DEPTH_TEST = 0x0B71,
-            LINE_STIPPLE = 0x0B24,
-            MAX_TEXTURE_STACK_DEPTH = 0x0D39,
-            LINE_WIDTH = 0x0B21,
-            MAX_LIGHTS = 0x0D31,
-            STENCIL_PASS_DEPTH_PASS = 0x0B96,
-            VERTEX_ARRAY_STRIDE = 0x807C,
-            PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX,
-            PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT,
-            EDGE_FLAG = 0x0B43,
-            POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT,
-            TEXTURE_1D = 0x0DE0,
-            POINT_SMOOTH_HINT = 0x0C51,
-            TEXTURE_GEN_S = 0x0C60,
-            TEXTURE_GEN_R = 0x0C62,
-            POINT_FADE_THRESHOLD_SIZE_SGIS = SGIS_point_parameters.POINT_FADE_THRESHOLD_SIZE_SGIS,
-            PACK_ALIGNMENT = 0x0D05,
-            DOUBLEBUFFER = 0x0C32,
-            REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX,
-            COLOR_ARRAY_COUNT_EXT = EXT_vertex_array.COLOR_ARRAY_COUNT_EXT,
-            PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX,
-            MAX_ACTIVE_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_ACTIVE_LIGHTS_SGIX,
-            BLEND_SRC = 0x0BE1,
-            DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS,
-            PACK_SKIP_ROWS = 0x0D03,
-            FOG_COLOR = 0x0B66,
-            LINE_SMOOTH = 0x0B20,
-            MAX_VIEWPORT_DIMS = 0x0D3A,
-            POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI,
-            COLOR_ARRAY = 0x8076,
-            MAX_TEXTURE_SIZE = 0x0D33,
-            FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX,
-            LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL,
-            CLIP_PLANE1 = ClipPlaneName.CLIP_PLANE1,
-            PIXEL_TEX_GEN_MODE_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_MODE_SGIX,
-            VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX,
-            LIGHT7 = LightName.LIGHT7,
-            COLOR_MATRIX_SGI = SGI_color_matrix.COLOR_MATRIX_SGI,
-            FEEDBACK_BUFFER_TYPE = 0x0DF2,
-            RED_BIAS = 0x0D15,
-            FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.FRAMEZOOM_FACTOR_SGIX,
-            LINE_WIDTH_GRANULARITY = 0x0B23,
-            MODELVIEW_MATRIX = 0x0BA6,
-            MAX_ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.MAX_ASYNC_HISTOGRAM_SGIX,
-            CULL_FACE = 0x0B44,
-            DITHER = 0x0BD0,
-            SMOOTH_LINE_WIDTH_GRANULARITY = VERSION_1_2.SMOOTH_LINE_WIDTH_GRANULARITY,
-            CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
-            POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI,
-            STENCIL_WRITEMASK = 0x0B98,
-            SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS,
-            STENCIL_FAIL = 0x0B94,
-            PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
-            BLUE_BIAS = 0x0D1B,
-            SHADE_MODEL = 0x0B54,
-            ASYNC_MARKER_SGIX = SGIX_async.ASYNC_MARKER_SGIX,
-            INDEX_BITS = 0x0D51,
-            ACCUM_GREEN_BITS = 0x0D59,
-            FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX,
-            SPRITE_MODE_SGIX = SGIX_sprite.SPRITE_MODE_SGIX,
-            PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX,
-            UNPACK_ROW_LENGTH = 0x0CF2,
-            CURRENT_RASTER_COLOR = 0x0B04,
-            TEXTURE_COORD_ARRAY_COUNT_EXT = EXT_vertex_array.TEXTURE_COORD_ARRAY_COUNT_EXT,
-            LOGIC_OP_MODE = 0x0BF0,
-            DEFORMATIONS_MASK_SGIX = SGIX_polynomial_ffd.DEFORMATIONS_MASK_SGIX,
-            POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_SGIS,
-            CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX,
-            CURRENT_RASTER_POSITION = 0x0B07,
-            SAMPLE_BUFFERS_SGIS = SGIS_multisample.SAMPLE_BUFFERS_SGIS,
-            DEPTH_WRITEMASK = 0x0B72,
-            DRAW_BUFFER = 0x0C01,
-            COLOR_ARRAY_STRIDE = 0x8083,
-            DEPTH_SCALE = 0x0D1E,
-            ALPHA_TEST = 0x0BC0,
-            NORMALIZE = 0x0BA1,
-            IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX,
-            MINMAX_EXT = EXT_histogram.MINMAX_EXT,
-            TEXTURE_BINDING_2D = 0x8069,
-            MAX_ATTRIB_STACK_DEPTH = 0x0D35,
-            LIGHT2 = LightName.LIGHT2,
-            TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
-            CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
-            MAP1_TEXTURE_COORD_1 = 0x0D93,
-            VIEWPORT = 0x0BA2,
-            INSTRUMENT_MEASUREMENTS_SGIX = SGIX_instruments.INSTRUMENT_MEASUREMENTS_SGIX,
-            POLYGON_SMOOTH_HINT = 0x0C53,
-            LIGHT_MODEL_TWO_SIDE = 0x0B52,
-            INDEX_OFFSET = 0x0D13,
-            MAP_COLOR = 0x0D10,
-            FOG_INDEX = 0x0B61,
-            ZOOM_Y = 0x0D17,
-            CLIP_PLANE2 = ClipPlaneName.CLIP_PLANE2,
-            STENCIL_TEST = 0x0B90,
-            ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX,
-            MAX_EVAL_ORDER = 0x0D30,
-            MAP2_NORMAL = 0x0DB2,
-            STENCIL_PASS_DEPTH_FAIL = 0x0B95,
-            VERTEX_ARRAY = 0x8074,
-            ALIASED_POINT_SIZE_RANGE = VERSION_1_2.ALIASED_POINT_SIZE_RANGE,
-            REFERENCE_PLANE_EQUATION_SGIX = SGIX_reference_plane.REFERENCE_PLANE_EQUATION_SGIX,
-            NORMAL_ARRAY = 0x8075,
-            UNPACK_SWAP_BYTES = 0x0CF0,
-            INDEX_CLEAR_VALUE = 0x0C20,
-            TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
-            LIGHT1 = LightName.LIGHT1,
-            CURRENT_TEXTURE_COORDS = 0x0B03,
-            MAP2_TEXTURE_COORD_1 = 0x0DB3,
-            TEXTURE_COORD_ARRAY = 0x8078,
-            BLEND_EQUATION_EXT = EXT_blend_minmax.BLEND_EQUATION_EXT,
-            POLYGON_STIPPLE = 0x0B42,
-            VERTEX_ARRAY_TYPE = 0x807B,
-            MAP1_INDEX = 0x0D91,
-            NORMAL_ARRAY_COUNT_EXT = EXT_vertex_array.NORMAL_ARRAY_COUNT_EXT,
-            CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
-            MAX_LIST_NESTING = 0x0B31,
-            STENCIL_BITS = 0x0D57,
-            SUBPIXEL_BITS = 0x0D50,
-            POLYGON_OFFSET_FILL = 0x8037,
-            LINE_WIDTH_RANGE = 0x0B22,
-            POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_RANGE_SGIX,
-            VERTEX_PRECLIP_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_SGIX,
-            POLYGON_OFFSET_POINT = 0x2A01,
-            ALPHA_TEST_REF = 0x0BC2,
-            RGBA_MODE = 0x0C31,
-            EDGE_FLAG_ARRAY_STRIDE = 0x808C,
-            LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
-            INDEX_SHIFT = 0x0D12,
-            MAP_STENCIL = 0x0D11,
-            TEXTURE_COORD_ARRAY_SIZE = 0x8088,
-            POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI,
-            TEXTURE_3D_BINDING_EXT = EXT_texture_object.TEXTURE_3D_BINDING_EXT,
-            PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
-            POLYGON_OFFSET_LINE = 0x2A02,
-            MAX_PIXEL_MAP_TABLE = 0x0D34,
-            POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI,
-            BLEND_DST = 0x0BE0,
-            TEXTURE_4D_BINDING_SGIS = SGIS_texture4D.TEXTURE_4D_BINDING_SGIS,
-            DEPTH_BIAS = 0x0D1F,
-            POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT,
-            MAP2_GRID_SEGMENTS = 0x0DD3,
-            MAX_CLIP_PLANES = 0x0D32,
-            MAX_ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_READ_PIXELS_SGIX,
-            DEPTH_BITS = 0x0D56,
-            POINT_SIZE_MAX_SGIS = SGIS_point_parameters.POINT_SIZE_MAX_SGIS,
-        }
-
-        public enum NV_packed_depth_stencil : uint
-        {
-            DEPTH_STENCIL_NV = 0x84F9,
-            UNSIGNED_INT_24_8_NV = 0x84FA,
-        }
-
-        public enum ATI_text_fragment_shader : uint
-        {
-            TEXT_FRAGMENT_SHADER_ATI = 0x8200,
-        }
-
-        public enum SGIS_texture_color_mask : uint
-        {
-            TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF,
-        }
-
-        public enum SGIX_flush_raster : uint
-        {
-        }
-
-        public enum SGIX_ycrcb_subsample : uint
-        {
-            PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3,
-            PACK_SUBSAMPLE_RATE_SGIX = 0x85A0,
-            PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2,
-            PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4,
-            UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1,
-        }
-
-        public enum SGIX_texture_lod_bias : uint
-        {
-            TEXTURE_LOD_BIAS_R_SGIX = 0x8190,
-            TEXTURE_LOD_BIAS_S_SGIX = 0x818E,
-            TEXTURE_LOD_BIAS_T_SGIX = 0x818F,
-        }
-
-        public enum TextureEnvMode : uint
-        {
-            REPLACE_EXT = EXT_texture.REPLACE_EXT,
-            MODULATE = 0x2100,
-            ADD = AccumOp.ADD,
-            DECAL = 0x2101,
-            BLEND = GetPName.BLEND,
-            TEXTURE_ENV_BIAS_SGIX = SGIX_texture_add_env.TEXTURE_ENV_BIAS_SGIX,
-        }
-
-        public enum EXT_texture_cube_map : uint
-        {
-            TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516,
-            TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518,
-            TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517,
-            TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A,
-            TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514,
-            REFLECTION_MAP_EXT = 0x8512,
-            TEXTURE_CUBE_MAP_EXT = 0x8513,
-            MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C,
-            TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519,
-            PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B,
-            TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515,
-            NORMAL_MAP_EXT = 0x8511,
-        }
-
-        public enum IndexPointerType : uint
-        {
-            DOUBLE = DataType.DOUBLE,
-            INT = DataType.INT,
-            SHORT = DataType.SHORT,
-            FLOAT = DataType.FLOAT,
-        }
-
-        public enum FogParameter : uint
-        {
-            FOG_END = GetPName.FOG_END,
-            FOG_COLOR = GetPName.FOG_COLOR,
-            FOG_DENSITY = GetPName.FOG_DENSITY,
-            FOG_START = GetPName.FOG_START,
-            FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX,
-            FOG_INDEX = GetPName.FOG_INDEX,
-            FOG_MODE = GetPName.FOG_MODE,
-        }
-
-        public enum SGIS_sharpen_texture : uint
-        {
-            LINEAR_SHARPEN_SGIS = 0x80AD,
-            LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE,
-            LINEAR_SHARPEN_COLOR_SGIS = 0x80AF,
-            SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0,
-        }
-
-        public enum AlphaFunction : uint
-        {
-            NEVER = 0x0200,
-            GEQUAL = 0x0206,
-            GREATER = 0x0204,
-            ALWAYS = 0x0207,
-            LEQUAL = 0x0203,
-            NOTEQUAL = 0x0205,
-            EQUAL = 0x0202,
-            LESS = 0x0201,
-        }
-
-        public enum NV_register_combiners2 : uint
-        {
-            PER_STAGE_CONSTANTS_NV = 0x8535,
-        }
-
-        public enum ARB_texture_env_crossbar : uint
-        {
-        }
-
-        public enum NV_texture_shader2 : uint
-        {
-            DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF,
-        }
-
-        public enum ATI_texture_env_combine3 : uint
-        {
-            MODULATE_ADD_ATI = 0x8744,
-            MODULATE_SIGNED_ADD_ATI = 0x8745,
-            MODULATE_SUBTRACT_ATI = 0x8746,
-        }
-
-        public enum EXT_misc_attribute : uint
-        {
-        }
-
-        public enum IBM_multimode_draw_arrays : uint
-        {
-        }
-
-        public enum SGI_color_matrix : uint
-        {
-            POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8,
-            POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA,
-            COLOR_MATRIX_SGI = 0x80B1,
-            POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6,
-            POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9,
-            POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6,
-            POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB,
-            COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2,
-            POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9,
-            POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7,
-            POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5,
-            POST_COLOR_MATRIX_RED_BIAS = 0x80B8,
-            MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3,
-            POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7,
-            COLOR_MATRIX_STACK_DEPTH = 0x80B2,
-            POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA,
-            COLOR_MATRIX = 0x80B1,
-            POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5,
-            POST_COLOR_MATRIX_RED_SCALE = 0x80B4,
-            MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3,
-            POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB,
-            POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4,
-        }
-
-        public enum SamplePatternSGIS : uint
-        {
-            _4PASS_0_SGIS = SGIS_multisample._4PASS_0_SGIS,
-            _4PASS_1_SGIS = SGIS_multisample._4PASS_1_SGIS,
-            _1PASS_SGIS = SGIS_multisample._1PASS_SGIS,
-            _2PASS_0_SGIS = SGIS_multisample._2PASS_0_SGIS,
-            _4PASS_2_SGIS = SGIS_multisample._4PASS_2_SGIS,
-            _2PASS_1_SGIS = SGIS_multisample._2PASS_1_SGIS,
-            _4PASS_3_SGIS = SGIS_multisample._4PASS_3_SGIS,
-        }
-
-        public enum SGIS_texture_filter4 : uint
-        {
-            TEXTURE_FILTER4_SIZE_SGIS = 0x8147,
-            FILTER4_SGIS = 0x8146,
-        }
-
-        public enum IBM_vertex_array_lists : uint
-        {
-            INDEX_ARRAY_LIST_IBM = 103073,
-            FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086,
-            SECONDARY_COLOR_ARRAY_LIST_IBM = 103077,
-            NORMAL_ARRAY_LIST_IBM = 103071,
-            COLOR_ARRAY_LIST_STRIDE_IBM = 103082,
-            TEXTURE_COORD_ARRAY_LIST_IBM = 103074,
-            EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085,
-            COLOR_ARRAY_LIST_IBM = 103072,
-            INDEX_ARRAY_LIST_STRIDE_IBM = 103083,
-            EDGE_FLAG_ARRAY_LIST_IBM = 103075,
-            SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087,
-            TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084,
-            FOG_COORDINATE_ARRAY_LIST_IBM = 103076,
-            VERTEX_ARRAY_LIST_IBM = 103070,
-            VERTEX_ARRAY_LIST_STRIDE_IBM = 103080,
-            NORMAL_ARRAY_LIST_STRIDE_IBM = 103081,
-        }
-
-        public enum NV_fence : uint
-        {
-            ALL_COMPLETED_NV = 0x84F2,
-            FENCE_CONDITION_NV = 0x84F4,
-            FENCE_STATUS_NV = 0x84F3,
-        }
-
-        public enum SGIX_async_histogram : uint
-        {
-            MAX_ASYNC_HISTOGRAM_SGIX = 0x832D,
-            ASYNC_HISTOGRAM_SGIX = 0x832C,
-        }
-
-        public enum EXT_gpu_program_parameters : uint
-        {
-        }
-
-        public enum EXT_clip_volume_hint : uint
-        {
-            CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0,
-        }
-
-        public enum EXT_multi_draw_arrays : uint
-        {
-        }
-
-        public enum SUN_mesh_array : uint
-        {
-            TRIANGLE_MESH_SUN = 0x8615,
-            QUAD_MESH_SUN = 0x8614,
-        }
-
-        public enum LightModelColorControl : uint
-        {
-            SEPARATE_SPECULAR_COLOR = VERSION_1_2.SEPARATE_SPECULAR_COLOR,
-            SINGLE_COLOR = VERSION_1_2.SINGLE_COLOR,
-        }
-
-        public enum ATI_element_array : uint
-        {
-            ELEMENT_ARRAY_POINTER_ATI = 0x876A,
-            ELEMENT_ARRAY_ATI = 0x8768,
-            ELEMENT_ARRAY_TYPE_ATI = 0x8769,
-        }
-
-        public enum NV_fragment_program : uint
-        {
-            FRAGMENT_PROGRAM_NV = 0x8870,
-            MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872,
-            PROGRAM_ERROR_STRING_NV = 0x8874,
-            MAX_TEXTURE_COORDS_NV = 0x8871,
-            FRAGMENT_PROGRAM_BINDING_NV = 0x8873,
-            MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868,
-        }
-
-        public enum EXT_subtexture : uint
-        {
-        }
-
-        public enum EXT_draw_range_elements : uint
-        {
-            MAX_ELEMENTS_INDICES_EXT = 0x80E9,
-            MAX_ELEMENTS_VERTICES_EXT = 0x80E8,
-        }
-
-        public enum TextureEnvTarget : uint
-        {
-            TEXTURE_ENV = 0x2300,
-        }
-
-        public enum AccumOp : uint
-        {
-            RETURN = 0x0102,
-            ADD = 0x0104,
-            LOAD = 0x0101,
-            ACCUM = 0x0100,
-            MULT = 0x0103,
-        }
-
-        public enum EXT_fog_coord : uint
-        {
-            FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456,
-            FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455,
-            FOG_COORDINATE_SOURCE_EXT = 0x8450,
-            FOG_COORDINATE_EXT = 0x8451,
-            FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454,
-            FOG_COORDINATE_ARRAY_EXT = 0x8457,
-            CURRENT_FOG_COORDINATE_EXT = 0x8453,
-            FRAGMENT_DEPTH_EXT = 0x8452,
-        }
-
-        public enum ATI_separate_stencil : uint
-        {
-            STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802,
-            STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803,
-            STENCIL_BACK_FAIL_ATI = 0x8801,
-            STENCIL_BACK_FUNC_ATI = 0x8800,
-        }
-
-        public enum OML_subsample : uint
-        {
-            FORMAT_SUBSAMPLE_24_24_OML = 0x8982,
-            FORMAT_SUBSAMPLE_244_244_OML = 0x8983,
-        }
-
-        public enum APPLE_specular_vector : uint
-        {
-            LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0,
-        }
-
-        public enum EXT_abgr : uint
-        {
-            ABGR_EXT = 0x8000,
-        }
-
-        public enum NV_copy_depth_to_color : uint
-        {
-            DEPTH_STENCIL_TO_BGRA_NV = 0x886F,
-            DEPTH_STENCIL_TO_RGBA_NV = 0x886E,
-        }
-
-        public enum NV_vertex_array_range : uint
-        {
-            MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520,
-            VERTEX_ARRAY_RANGE_VALID_NV = 0x851F,
-            VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E,
-            VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521,
-            VERTEX_ARRAY_RANGE_NV = 0x851D,
-        }
-
-        public enum GetColorTableParameterPNameSGI : uint
-        {
-            COLOR_TABLE_BLUE_SIZE_SGI = SGI_color_table.COLOR_TABLE_BLUE_SIZE_SGI,
-            COLOR_TABLE_FORMAT_SGI = SGI_color_table.COLOR_TABLE_FORMAT_SGI,
-            COLOR_TABLE_ALPHA_SIZE_SGI = SGI_color_table.COLOR_TABLE_ALPHA_SIZE_SGI,
-            COLOR_TABLE_INTENSITY_SIZE_SGI = SGI_color_table.COLOR_TABLE_INTENSITY_SIZE_SGI,
-            COLOR_TABLE_GREEN_SIZE_SGI = SGI_color_table.COLOR_TABLE_GREEN_SIZE_SGI,
-            COLOR_TABLE_LUMINANCE_SIZE_SGI = SGI_color_table.COLOR_TABLE_LUMINANCE_SIZE_SGI,
-            COLOR_TABLE_WIDTH_SGI = SGI_color_table.COLOR_TABLE_WIDTH_SGI,
-            COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI,
-            COLOR_TABLE_RED_SIZE_SGI = SGI_color_table.COLOR_TABLE_RED_SIZE_SGI,
-            COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI,
-        }
-
-        public enum SGIX_texture_add_env : uint
-        {
-            TEXTURE_ENV_BIAS_SGIX = 0x80BE,
-        }
-
-        public enum PixelMap : uint
-        {
-            PIXEL_MAP_B_TO_B = GetPixelMap.PIXEL_MAP_B_TO_B,
-            PIXEL_MAP_S_TO_S = GetPixelMap.PIXEL_MAP_S_TO_S,
-            PIXEL_MAP_R_TO_R = GetPixelMap.PIXEL_MAP_R_TO_R,
-            PIXEL_MAP_I_TO_B = GetPixelMap.PIXEL_MAP_I_TO_B,
-            PIXEL_MAP_I_TO_G = GetPixelMap.PIXEL_MAP_I_TO_G,
-            PIXEL_MAP_I_TO_A = GetPixelMap.PIXEL_MAP_I_TO_A,
-            PIXEL_MAP_A_TO_A = GetPixelMap.PIXEL_MAP_A_TO_A,
-            PIXEL_MAP_G_TO_G = GetPixelMap.PIXEL_MAP_G_TO_G,
-            PIXEL_MAP_I_TO_I = GetPixelMap.PIXEL_MAP_I_TO_I,
-            PIXEL_MAP_I_TO_R = GetPixelMap.PIXEL_MAP_I_TO_R,
-        }
-
-        public enum ARB_occlusion_query : uint
-        {
-            QUERY_RESULT_ARB = 0x8866,
-            CURRENT_QUERY_ARB = 0x8865,
-            QUERY_RESULT_AVAILABLE_ARB = 0x8867,
-            SAMPLES_PASSED_ARB = 0x8914,
-            QUERY_COUNTER_BITS_ARB = 0x8864,
-        }
-
-        public enum NV_float_buffer : uint
-        {
-            FLOAT_R16_NV = 0x8884,
-            FLOAT_RG_NV = 0x8881,
-            FLOAT_RGB_NV = 0x8882,
-            FLOAT_R32_NV = 0x8885,
-            FLOAT_RG16_NV = 0x8886,
-            FLOAT_R_NV = 0x8880,
-            FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D,
-            FLOAT_RGB32_NV = 0x8889,
-            FLOAT_RGBA_MODE_NV = 0x888E,
-            TEXTURE_FLOAT_COMPONENTS_NV = 0x888C,
-            FLOAT_RGBA_NV = 0x8883,
-            FLOAT_RGBA16_NV = 0x888A,
-            FLOAT_RGBA32_NV = 0x888B,
-            FLOAT_RGB16_NV = 0x8888,
-            FLOAT_RG32_NV = 0x8887,
-        }
-
-        public enum IBM_cull_vertex : uint
-        {
-            CULL_VERTEX_IBM = 103050,
-        }
-
-        public enum NV_texture_rectangle : uint
-        {
-            TEXTURE_BINDING_RECTANGLE_NV = 0x84F6,
-            PROXY_TEXTURE_RECTANGLE_NV = 0x84F7,
-            MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8,
-            TEXTURE_RECTANGLE_NV = 0x84F5,
-        }
-
-        public enum LightEnvModeSGIX : uint
-        {
-            REPLACE = StencilOp.REPLACE,
-            MODULATE = TextureEnvMode.MODULATE,
-            ADD = AccumOp.ADD,
-        }
-
-        public enum ARB_fragment_program_shadow : uint
-        {
-        }
-
-        public enum SGIX_subsample : uint
-        {
-            PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3,
-            PACK_SUBSAMPLE_RATE_SGIX = 0x85A0,
-            PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2,
-            PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4,
-            UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1,
-        }
-
-        public enum EXT_stencil_two_side : uint
-        {
-            ACTIVE_STENCIL_FACE_EXT = 0x8911,
-            STENCIL_TEST_TWO_SIDE_EXT = 0x8910,
-        }
-
-        public enum SGIX_ir_instrument1 : uint
-        {
-            IR_INSTRUMENT1_SGIX = 0x817F,
-        }
-
-        public enum ARB_transpose_matrix : uint
-        {
-            TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5,
-            TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4,
-            TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6,
-            TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3,
-        }
-
-        public enum PixelType : uint
-        {
-            UNSIGNED_INT = DataType.UNSIGNED_INT,
-            UNSIGNED_SHORT_5_5_5_1_EXT = EXT_packed_pixels.UNSIGNED_SHORT_5_5_5_1_EXT,
-            FLOAT = DataType.FLOAT,
-            UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
-            SHORT = DataType.SHORT,
-            BYTE = DataType.BYTE,
-            UNSIGNED_INT_8_8_8_8_EXT = EXT_packed_pixels.UNSIGNED_INT_8_8_8_8_EXT,
-            UNSIGNED_BYTE_3_3_2_EXT = EXT_packed_pixels.UNSIGNED_BYTE_3_3_2_EXT,
-            INT = DataType.INT,
-            BITMAP = 0x1A00,
-            UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
-            UNSIGNED_INT_10_10_10_2_EXT = EXT_packed_pixels.UNSIGNED_INT_10_10_10_2_EXT,
-            UNSIGNED_SHORT_4_4_4_4_EXT = EXT_packed_pixels.UNSIGNED_SHORT_4_4_4_4_EXT,
-        }
-
-        public enum EXT_texture_env_combine : uint
-        {
-            SOURCE0_RGB_EXT = 0x8580,
-            COMBINE_RGB_EXT = 0x8571,
-            SOURCE1_RGB_EXT = 0x8581,
-            CONSTANT_EXT = 0x8576,
-            SOURCE1_ALPHA_EXT = 0x8589,
-            SOURCE2_ALPHA_EXT = 0x858A,
-            SOURCE2_RGB_EXT = 0x8582,
-            OPERAND0_RGB_EXT = 0x8590,
-            OPERAND0_ALPHA_EXT = 0x8598,
-            RGB_SCALE_EXT = 0x8573,
-            OPERAND1_RGB_EXT = 0x8591,
-            SOURCE0_ALPHA_EXT = 0x8588,
-            OPERAND2_ALPHA_EXT = 0x859A,
-            INTERPOLATE_EXT = 0x8575,
-            COMBINE_EXT = 0x8570,
-            OPERAND1_ALPHA_EXT = 0x8599,
-            OPERAND2_RGB_EXT = 0x8592,
-            PREVIOUS_EXT = 0x8578,
-            ADD_SIGNED_EXT = 0x8574,
-            PRIMARY_COLOR_EXT = 0x8577,
-            COMBINE_ALPHA_EXT = 0x8572,
-        }
-
-        public enum ATI_vertex_streams : uint
-        {
-            VERTEX_STREAM6_ATI = 0x8772,
-            VERTEX_STREAM1_ATI = 0x876D,
-            VERTEX_STREAM3_ATI = 0x876F,
-            MAX_VERTEX_STREAMS_ATI = 0x876B,
-            VERTEX_STREAM4_ATI = 0x8770,
-            VERTEX_STREAM0_ATI = 0x876C,
-            VERTEX_STREAM2_ATI = 0x876E,
-            VERTEX_SOURCE_ATI = 0x8774,
-            VERTEX_STREAM7_ATI = 0x8773,
-            VERTEX_STREAM5_ATI = 0x8771,
-        }
-
-        public enum EXT_point_parameters : uint
-        {
-            DISTANCE_ATTENUATION_EXT = 0x8129,
-            POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128,
-            POINT_SIZE_MAX_EXT = 0x8127,
-            POINT_SIZE_MIN_EXT = 0x8126,
-        }
-
-        public enum SGIX_fog_scale : uint
-        {
-            FOG_SCALE_SGIX = 0x81FC,
-            FOG_SCALE_VALUE_SGIX = 0x81FD,
-        }
-
-        public enum OML_interlace : uint
-        {
-            INTERLACE_READ_OML = 0x8981,
-            INTERLACE_OML = 0x8980,
-        }
-
-        public enum SGIS_texture_select : uint
-        {
-            DUAL_ALPHA16_SGIS = 0x8113,
-            QUAD_ALPHA8_SGIS = 0x811F,
-            DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C,
-            DUAL_LUMINANCE12_SGIS = 0x8116,
-            DUAL_ALPHA4_SGIS = 0x8110,
-            QUAD_TEXTURE_SELECT_SGIS = 0x8125,
-            DUAL_ALPHA12_SGIS = 0x8112,
-            QUAD_INTENSITY4_SGIS = 0x8122,
-            DUAL_INTENSITY16_SGIS = 0x811B,
-            DUAL_INTENSITY4_SGIS = 0x8118,
-            DUAL_LUMINANCE4_SGIS = 0x8114,
-            QUAD_INTENSITY8_SGIS = 0x8123,
-            DUAL_LUMINANCE16_SGIS = 0x8117,
-            DUAL_LUMINANCE8_SGIS = 0x8115,
-            QUAD_LUMINANCE8_SGIS = 0x8121,
-            DUAL_TEXTURE_SELECT_SGIS = 0x8124,
-            DUAL_ALPHA8_SGIS = 0x8111,
-            DUAL_INTENSITY12_SGIS = 0x811A,
-            DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D,
-            QUAD_LUMINANCE4_SGIS = 0x8120,
-            DUAL_INTENSITY8_SGIS = 0x8119,
-            QUAD_ALPHA4_SGIS = 0x811E,
-        }
-
-        public enum APPLE_transform_hint : uint
-        {
-            TRANSFORM_HINT_APPLE = 0x85B1,
-        }
-
-        public enum EXT_texture_compression_s3tc : uint
-        {
-            COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0,
-            COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1,
-            COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3,
-            COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2,
-        }
-
-        public enum ARB_draw_buffers : uint
-        {
-            DRAW_BUFFER13_ARB = 0x8832,
-            DRAW_BUFFER4_ARB = 0x8829,
-            DRAW_BUFFER1_ARB = 0x8826,
-            MAX_DRAW_BUFFERS_ARB = 0x8824,
-            DRAW_BUFFER2_ARB = 0x8827,
-            DRAW_BUFFER0_ARB = 0x8825,
-            DRAW_BUFFER8_ARB = 0x882D,
-            DRAW_BUFFER7_ARB = 0x882C,
-            DRAW_BUFFER10_ARB = 0x882F,
-            DRAW_BUFFER5_ARB = 0x882A,
-            DRAW_BUFFER15_ARB = 0x8834,
-            DRAW_BUFFER14_ARB = 0x8833,
-            DRAW_BUFFER3_ARB = 0x8828,
-            DRAW_BUFFER6_ARB = 0x882B,
-            DRAW_BUFFER12_ARB = 0x8831,
-            DRAW_BUFFER11_ARB = 0x8830,
-            DRAW_BUFFER9_ARB = 0x882E,
-        }
-
-        public enum EXT_index_material : uint
-        {
-            INDEX_MATERIAL_FACE_EXT = 0x81BA,
-            INDEX_MATERIAL_EXT = 0x81B8,
-            INDEX_MATERIAL_PARAMETER_EXT = 0x81B9,
-        }
-
-        public enum EXT_stencil_clear_tag : uint
-        {
-            STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3,
-            STENCIL_TAG_BITS_EXT = 0x88F2,
-        }
-
-        public enum EXT_framebuffer_object : uint
-        {
-            FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC,
-            COLOR_ATTACHMENT3_EXT = 0x8CE3,
-            COLOR_ATTACHMENT1_EXT = 0x8CE1,
-            FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0,
-            FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4,
-            RENDERBUFFER_EXT = 0x8D41,
-            COLOR_ATTACHMENT15_EXT = 0x8CEF,
-            COLOR_ATTACHMENT13_EXT = 0x8CED,
-            RENDERBUFFER_HEIGHT_EXT = 0x8D43,
-            COLOR_ATTACHMENT14_EXT = 0x8CEE,
-            COLOR_ATTACHMENT12_EXT = 0x8CEC,
-            RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44,
-            RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53,
-            FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9,
-            STENCIL_INDEX4_EXT = 0x8D47,
-            FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2,
-            COLOR_ATTACHMENT6_EXT = 0x8CE6,
-            FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7,
-            FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA,
-            RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54,
-            FRAMEBUFFER_BINDING_EXT = 0x8CA6,
-            COLOR_ATTACHMENT8_EXT = 0x8CE8,
-            FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6,
-            COLOR_ATTACHMENT2_EXT = 0x8CE2,
-            COLOR_ATTACHMENT9_EXT = 0x8CE9,
-            FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3,
-            FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB,
-            MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF,
-            RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51,
-            STENCIL_INDEX8_EXT = 0x8D48,
-            COLOR_ATTACHMENT7_EXT = 0x8CE7,
-            MAX_RENDERBUFFER_SIZE_EXT = 0x84E8,
-            STENCIL_INDEX1_EXT = 0x8D46,
-            DEPTH_ATTACHMENT_EXT = 0x8D00,
-            COLOR_ATTACHMENT0_EXT = 0x8CE0,
-            INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506,
-            RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52,
-            FRAMEBUFFER_EXT = 0x8D40,
-            RENDERBUFFER_WIDTH_EXT = 0x8D42,
-            STENCIL_INDEX16_EXT = 0x8D49,
-            FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = 0x8CD8,
-            COLOR_ATTACHMENT5_EXT = 0x8CE5,
-            FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD,
-            RENDERBUFFER_RED_SIZE_EXT = 0x8D50,
-            COLOR_ATTACHMENT11_EXT = 0x8CEB,
-            FRAMEBUFFER_COMPLETE_EXT = 0x8CD5,
-            COLOR_ATTACHMENT4_EXT = 0x8CE4,
-            COLOR_ATTACHMENT10_EXT = 0x8CEA,
-            RENDERBUFFER_BINDING_EXT = 0x8CA7,
-            RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55,
-            FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1,
-            STENCIL_ATTACHMENT_EXT = 0x8D20,
-        }
-
-        public enum SGIX_async : uint
-        {
-            ASYNC_MARKER_SGIX = 0x8329,
-        }
-
-        public enum EXT_texture_env_add : uint
-        {
-        }
-
-        public enum PixelTransferParameter : uint
-        {
-            POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT,
-            DEPTH_BIAS = GetPName.DEPTH_BIAS,
-            POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI,
-            POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT,
-            BLUE_SCALE = GetPName.BLUE_SCALE,
-            POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI,
-            BLUE_BIAS = GetPName.BLUE_BIAS,
-            POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI,
-            INDEX_OFFSET = GetPName.INDEX_OFFSET,
-            POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT,
-            POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI,
-            MAP_COLOR = GetPName.MAP_COLOR,
-            POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI,
-            MAP_STENCIL = GetPName.MAP_STENCIL,
-            POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT,
-            INDEX_SHIFT = GetPName.INDEX_SHIFT,
-            POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI,
-            POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT,
-            POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT,
-            POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI,
-            POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI,
-            RED_SCALE = GetPName.RED_SCALE,
-            GREEN_BIAS = GetPName.GREEN_BIAS,
-            RED_BIAS = GetPName.RED_BIAS,
-            POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT,
-            GREEN_SCALE = GetPName.GREEN_SCALE,
-            ALPHA_SCALE = GetPName.ALPHA_SCALE,
-            ALPHA_BIAS = GetPName.ALPHA_BIAS,
-            DEPTH_SCALE = GetPName.DEPTH_SCALE,
-            POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT,
-        }
-
-        public enum VERSION_1_3 : uint
-        {
-            TEXTURE14 = 0x84CE,
-            TEXTURE17 = 0x84D1,
-            TEXTURE16 = 0x84D0,
-            TEXTURE11 = 0x84CB,
-            TEXTURE10 = 0x84CA,
-            TEXTURE13 = 0x84CD,
-            TEXTURE12 = 0x84CC,
-            SAMPLE_ALPHA_TO_ONE = 0x809F,
-            TEXTURE_BINDING_CUBE_MAP = 0x8514,
-            TEXTURE19 = 0x84D3,
-            TEXTURE18 = 0x84D2,
-            PRIMARY_COLOR = 0x8577,
-            MULTISAMPLE = 0x809D,
-            TRANSPOSE_COLOR_MATRIX = 0x84E6,
-            TRANSPOSE_PROJECTION_MATRIX = 0x84E4,
-            CONSTANT = 0x8576,
-            COMBINE = 0x8570,
-            MULTISAMPLE_BIT = 0x20000000,
-            SOURCE2_ALPHA = 0x858A,
-            SAMPLES = 0x80A9,
-            COMPRESSED_ALPHA = 0x84E9,
-            TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517,
-            SAMPLE_COVERAGE = 0x80A0,
-            TRANSPOSE_MODELVIEW_MATRIX = 0x84E3,
-            SAMPLE_ALPHA_TO_COVERAGE = 0x809E,
-            SUBTRACT = 0x84E7,
-            SAMPLE_BUFFERS = 0x80A8,
-            DOT3_RGBA = 0x86AF,
-            DOT3_RGB = 0x86AE,
-            SOURCE1_ALPHA = 0x8589,
-            TEXTURE6 = 0x84C6,
-            TEXTURE2 = 0x84C2,
-            COMPRESSED_RGB = 0x84ED,
-            COMPRESSED_RGBA = 0x84EE,
-            TEXTURE9 = 0x84C9,
-            TEXTURE31 = 0x84DF,
-            TEXTURE30 = 0x84DE,
-            OPERAND1_ALPHA = 0x8599,
-            CLIENT_ACTIVE_TEXTURE = 0x84E1,
-            INTERPOLATE = 0x8575,
-            OPERAND1_RGB = 0x8591,
-            SOURCE2_RGB = 0x8582,
-            MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C,
-            TEXTURE_COMPRESSED = 0x86A1,
-            TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A,
-            RGB_SCALE = 0x8573,
-            SAMPLE_COVERAGE_INVERT = 0x80AB,
-            TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519,
-            NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2,
-            COMPRESSED_TEXTURE_FORMATS = 0x86A3,
-            TEXTURE5 = 0x84C5,
-            TEXTURE1 = 0x84C1,
-            COMBINE_RGB = 0x8571,
-            TEXTURE25 = 0x84D9,
-            TEXTURE8 = 0x84C8,
-            TEXTURE27 = 0x84DB,
-            TEXTURE26 = 0x84DA,
-            TEXTURE21 = 0x84D5,
-            TEXTURE20 = 0x84D4,
-            TEXTURE23 = 0x84D7,
-            TEXTURE22 = 0x84D6,
-            SAMPLE_COVERAGE_VALUE = 0x80AA,
-            TEXTURE29 = 0x84DD,
-            TEXTURE28 = 0x84DC,
-            TEXTURE_CUBE_MAP = 0x8513,
-            SOURCE0_ALPHA = 0x8588,
-            TEXTURE24 = 0x84D8,
-            SOURCE0_RGB = 0x8580,
-            ADD_SIGNED = 0x8574,
-            OPERAND0_ALPHA = 0x8598,
-            REFLECTION_MAP = 0x8512,
-            ACTIVE_TEXTURE = 0x84E0,
-            TRANSPOSE_TEXTURE_MATRIX = 0x84E5,
-            SOURCE1_RGB = 0x8581,
-            TEXTURE15 = 0x84CF,
-            COMPRESSED_LUMINANCE = 0x84EA,
-            CLAMP_TO_BORDER = 0x812D,
-            TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516,
-            OPERAND2_ALPHA = 0x859A,
-            COMPRESSED_INTENSITY = 0x84EC,
-            TEXTURE0 = 0x84C0,
-            NORMAL_MAP = 0x8511,
-            COMPRESSED_LUMINANCE_ALPHA = 0x84EB,
-            PROXY_TEXTURE_CUBE_MAP = 0x851B,
-            TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0,
-            OPERAND2_RGB = 0x8592,
-            TEXTURE4 = 0x84C4,
-            OPERAND0_RGB = 0x8590,
-            MAX_TEXTURE_UNITS = 0x84E2,
-            TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515,
-            TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518,
-            TEXTURE_COMPRESSION_HINT = 0x84EF,
-            COMBINE_ALPHA = 0x8572,
-            PREVIOUS = 0x8578,
-            TEXTURE7 = 0x84C7,
-            TEXTURE3 = 0x84C3,
-        }
-
-        public enum NV_vertex_program2 : uint
-        {
-        }
-
-        public enum EXT_polygon_offset : uint
-        {
-            POLYGON_OFFSET_BIAS_EXT = 0x8039,
-            POLYGON_OFFSET_EXT = 0x8037,
-            POLYGON_OFFSET_FACTOR_EXT = 0x8038,
-        }
-
-        public enum SGIX_texture_coordinate_clamp : uint
-        {
-            FOG_FACTOR_TO_ALPHA_SGIX = 0x836F,
-            TEXTURE_MAX_CLAMP_S_SGIX = 0x8369,
-            TEXTURE_MAX_CLAMP_R_SGIX = 0x836B,
-            TEXTURE_MAX_CLAMP_T_SGIX = 0x836A,
-        }
-
-        public enum SGIX_instruments : uint
-        {
-            INSTRUMENT_MEASUREMENTS_SGIX = 0x8181,
-            INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180,
-        }
-
-        public enum VERSION_2_0 : uint
-        {
-            MAX_VARYING_FLOATS = 0x8B4B,
-            VERTEX_ATTRIB_ARRAY_POINTER = 0x8645,
-            VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622,
-            DRAW_BUFFER13 = 0x8832,
-            VERTEX_PROGRAM_POINT_SIZE = 0x8642,
-            MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C,
-            MAX_TEXTURE_COORDS = 0x8871,
-            FLOAT_MAT4 = 0x8B5C,
-            SAMPLER_3D = 0x8B5F,
-            SAMPLER_1D_SHADOW = 0x8B61,
-            SAMPLER_1D = 0x8B5D,
-            ATTACHED_SHADERS = 0x8B85,
-            ACTIVE_ATTRIBUTES = 0x8B89,
-            LINK_STATUS = 0x8B82,
-            FLOAT_VEC4 = 0x8B52,
-            DRAW_BUFFER4 = 0x8829,
-            DRAW_BUFFER8 = 0x882D,
-            MAX_DRAW_BUFFERS = 0x8824,
-            INT_VEC2 = 0x8B53,
-            POINT_SPRITE_COORD_ORIGIN = 0x8CA0,
-            MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49,
-            SAMPLER_CUBE = 0x8B60,
-            DRAW_BUFFER12 = 0x8831,
-            DRAW_BUFFER11 = 0x8830,
-            DRAW_BUFFER10 = 0x882F,
-            FRAGMENT_SHADER = 0x8B30,
-            STENCIL_BACK_REF = 0x8CA3,
-            DRAW_BUFFER15 = 0x8834,
-            DRAW_BUFFER14 = 0x8833,
-            BOOL = 0x8B56,
-            CURRENT_VERTEX_ATTRIB = 0x8626,
-            ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A,
-            FLOAT_MAT2 = 0x8B5A,
-            ACTIVE_UNIFORMS = 0x8B86,
-            SAMPLER_2D = 0x8B5E,
-            INFO_LOG_LENGTH = 0x8B84,
-            MAX_VERTEX_ATTRIBS = 0x8869,
-            DRAW_BUFFER0 = 0x8825,
-            CURRENT_PROGRAM = 0x8B8D,
-            SHADING_LANGUAGE_VERSION = 0x8B8C,
-            FLOAT_VEC3 = 0x8B51,
-            DRAW_BUFFER5 = 0x882A,
-            DRAW_BUFFER9 = 0x882E,
-            STENCIL_BACK_FUNC = 0x8800,
-            COMPILE_STATUS = 0x8B81,
-            INT_VEC3 = 0x8B54,
-            STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802,
-            VERTEX_ATTRIB_ARRAY_SIZE = 0x8623,
-            BLEND_EQUATION_ALPHA = 0x883D,
-            STENCIL_BACK_PASS_DEPTH_PASS = 0x8803,
-            UPPER_LEFT = 0x8CA2,
-            VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624,
-            FLOAT_MAT3 = 0x8B5B,
-            SAMPLER_2D_SHADOW = 0x8B62,
-            VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A,
-            FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B,
-            BLEND_EQUATION_RGB = ARB_imaging.BLEND_EQUATION,
-            DRAW_BUFFER2 = 0x8827,
-            SHADER_SOURCE_LENGTH = 0x8B88,
-            DRAW_BUFFER7 = 0x882C,
-            SHADER_TYPE = 0x8B4F,
-            DRAW_BUFFER1 = 0x8826,
-            MAX_TEXTURE_IMAGE_UNITS = 0x8872,
-            POINT_SPRITE = 0x8861,
-            DRAW_BUFFER6 = 0x882B,
-            STENCIL_BACK_WRITEMASK = 0x8CA5,
-            STENCIL_BACK_VALUE_MASK = 0x8CA4,
-            COORD_REPLACE = 0x8862,
-            VERTEX_ATTRIB_ARRAY_TYPE = 0x8625,
-            LOWER_LEFT = 0x8CA1,
-            INT_VEC4 = 0x8B55,
-            FLOAT_VEC2 = 0x8B50,
-            MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A,
-            VALIDATE_STATUS = 0x8B83,
-            VERTEX_SHADER = 0x8B31,
-            MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D,
-            VERTEX_PROGRAM_TWO_SIDE = 0x8643,
-            DELETE_STATUS = 0x8B80,
-            STENCIL_BACK_FAIL = 0x8801,
-            ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87,
-            DRAW_BUFFER3 = 0x8828,
-            BOOL_VEC4 = 0x8B59,
-            BOOL_VEC3 = 0x8B58,
-            BOOL_VEC2 = 0x8B57,
-        }
-
-        public enum ARB_multitexture : uint
-        {
-            TEXTURE13_ARB = 0x84CD,
-            TEXTURE7_ARB = 0x84C7,
-            TEXTURE21_ARB = 0x84D5,
-            TEXTURE24_ARB = 0x84D8,
-            TEXTURE19_ARB = 0x84D3,
-            TEXTURE5_ARB = 0x84C5,
-            TEXTURE16_ARB = 0x84D0,
-            TEXTURE27_ARB = 0x84DB,
-            TEXTURE17_ARB = 0x84D1,
-            MAX_TEXTURE_UNITS_ARB = 0x84E2,
-            TEXTURE2_ARB = 0x84C2,
-            TEXTURE20_ARB = 0x84D4,
-            TEXTURE31_ARB = 0x84DF,
-            TEXTURE12_ARB = 0x84CC,
-            TEXTURE18_ARB = 0x84D2,
-            TEXTURE15_ARB = 0x84CF,
-            TEXTURE10_ARB = 0x84CA,
-            ACTIVE_TEXTURE_ARB = 0x84E0,
-            TEXTURE23_ARB = 0x84D7,
-            TEXTURE0_ARB = 0x84C0,
-            TEXTURE29_ARB = 0x84DD,
-            TEXTURE26_ARB = 0x84DA,
-            TEXTURE8_ARB = 0x84C8,
-            TEXTURE3_ARB = 0x84C3,
-            TEXTURE30_ARB = 0x84DE,
-            TEXTURE11_ARB = 0x84CB,
-            TEXTURE9_ARB = 0x84C9,
-            CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1,
-            TEXTURE14_ARB = 0x84CE,
-            TEXTURE6_ARB = 0x84C6,
-            TEXTURE22_ARB = 0x84D6,
-            TEXTURE28_ARB = 0x84DC,
-            TEXTURE25_ARB = 0x84D9,
-            TEXTURE1_ARB = 0x84C1,
-            TEXTURE4_ARB = 0x84C4,
-        }
-
-        public enum EXT_histogram : uint
-        {
-            HISTOGRAM_WIDTH = 0x8026,
-            PROXY_HISTOGRAM = 0x8025,
-            MINMAX_EXT = 0x802E,
-            MINMAX_SINK_EXT = 0x8030,
-            MINMAX_FORMAT_EXT = 0x802F,
-            HISTOGRAM_BLUE_SIZE = 0x802A,
-            HISTOGRAM_SINK_EXT = 0x802D,
-            HISTOGRAM_LUMINANCE_SIZE = 0x802C,
-            HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C,
-            HISTOGRAM_EXT = 0x8024,
-            HISTOGRAM_ALPHA_SIZE = 0x802B,
-            HISTOGRAM_FORMAT_EXT = 0x8027,
-            HISTOGRAM_RED_SIZE_EXT = 0x8028,
-            MINMAX = 0x802E,
-            MINMAX_SINK = 0x8030,
-            PROXY_HISTOGRAM_EXT = 0x8025,
-            HISTOGRAM_RED_SIZE = 0x8028,
-            HISTOGRAM_ALPHA_SIZE_EXT = 0x802B,
-            HISTOGRAM_BLUE_SIZE_EXT = 0x802A,
-            MINMAX_FORMAT = 0x802F,
-            HISTOGRAM_WIDTH_EXT = 0x8026,
-            HISTOGRAM_FORMAT = 0x8027,
-            TABLE_TOO_LARGE = 0x8031,
-            HISTOGRAM_SINK = 0x802D,
-            HISTOGRAM_GREEN_SIZE_EXT = 0x8029,
-            TABLE_TOO_LARGE_EXT = 0x8031,
-            HISTOGRAM = 0x8024,
-            HISTOGRAM_GREEN_SIZE = 0x8029,
-        }
-
-        public enum PixelFormat : uint
-        {
-            CMYK_EXT = EXT_cmyka.CMYK_EXT,
-            YCRCB_444_SGIX = SGIX_ycrcb.YCRCB_444_SGIX,
-            R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX,
-            ALPHA = 0x1906,
-            RGBA = 0x1908,
-            GREEN = 0x1904,
-            R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX,
-            LUMINANCE_ALPHA = 0x190A,
-            STENCIL_INDEX = 0x1901,
-            RED = 0x1903,
-            BLUE = 0x1905,
-            CMYKA_EXT = EXT_cmyka.CMYKA_EXT,
-            ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX,
-            LUMINANCE = 0x1909,
-            LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX,
-            YCRCB_422_SGIX = SGIX_ycrcb.YCRCB_422_SGIX,
-            ABGR_EXT = EXT_abgr.ABGR_EXT,
-            COLOR_INDEX = 0x1900,
-            RGB = 0x1907,
-            LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX,
-            DEPTH_COMPONENT = 0x1902,
-        }
-
-        public enum NV_occlusion_query : uint
-        {
-            CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865,
-            PIXEL_COUNT_NV = 0x8866,
-            PIXEL_COUNTER_BITS_NV = 0x8864,
-            PIXEL_COUNT_AVAILABLE_NV = 0x8867,
-        }
-
-        public enum MapTarget : uint
-        {
-            MAP2_COLOR_4 = GetPName.MAP2_COLOR_4,
-            MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4,
-            MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3,
-            GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX,
-            MAP2_INDEX = GetPName.MAP2_INDEX,
-            MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1,
-            TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX,
-            MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1,
-            MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4,
-            MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3,
-            MAP1_INDEX = GetPName.MAP1_INDEX,
-            MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4,
-            MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2,
-            MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2,
-            MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3,
-            MAP1_COLOR_4 = GetPName.MAP1_COLOR_4,
-            MAP2_NORMAL = GetPName.MAP2_NORMAL,
-            MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4,
-            MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3,
-            MAP1_NORMAL = GetPName.MAP1_NORMAL,
-        }
-
-        public enum ListParameterName : uint
-        {
-            LIST_PRIORITY_SGIX = SGIX_list_priority.LIST_PRIORITY_SGIX,
-        }
-
-        public enum IBM_texture_mirrored_repeat : uint
-        {
-            MIRRORED_REPEAT_IBM = 0x8370,
-        }
-
-        public enum SGIX_vertex_preclip : uint
-        {
-            VERTEX_PRECLIP_HINT_SGIX = 0x83EF,
-            VERTEX_PRECLIP_SGIX = 0x83EE,
-        }
-
-        public enum PixelStoreSubsampleRate : uint
-        {
-            PIXEL_SUBSAMPLE_2424_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_2424_SGIX,
-            PIXEL_SUBSAMPLE_4444_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4444_SGIX,
-            PIXEL_SUBSAMPLE_4242_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4242_SGIX,
-        }
-
-        public enum SUN_convolution_border_modes : uint
-        {
-            WRAP_BORDER_SUN = 0x81D4,
-        }
-
-        public enum SGIS_generate_mipmap : uint
-        {
-            GENERATE_MIPMAP_HINT = 0x8192,
-            TEXTURE_DEFORMATION_SGIX = 0x8195,
-            GENERATE_MIPMAP = 0x8191,
-            GEOMETRY_DEFORMATION_SGIX = 0x8194,
-            GENERATE_MIPMAP_HINT_SGIS = 0x8192,
-            GENERATE_MIPMAP_SGIS = 0x8191,
-            DEFORMATIONS_MASK_SGIX = 0x8196,
-            MAX_DEFORMATION_ORDER_SGIX = 0x8197,
-        }
-
-        public enum EXT_index_array_formats : uint
-        {
-            IUI_N3F_V2F_EXT = 0x81AF,
-            T2F_IUI_V3F_EXT = 0x81B2,
-            T2F_IUI_V2F_EXT = 0x81B1,
-            IUI_N3F_V3F_EXT = 0x81B0,
-            T2F_IUI_N3F_V3F_EXT = 0x81B4,
-            T2F_IUI_N3F_V2F_EXT = 0x81B3,
-            IUI_V3F_EXT = 0x81AE,
-            IUI_V2F_EXT = 0x81AD,
-        }
-
-        public enum BlendEquationModeEXT : uint
-        {
-            MAX_EXT = EXT_blend_minmax.MAX_EXT,
-            LOGIC_OP = GetPName.LOGIC_OP,
-            FUNC_ADD_EXT = EXT_blend_minmax.FUNC_ADD_EXT,
-            FUNC_SUBTRACT_EXT = EXT_blend_subtract.FUNC_SUBTRACT_EXT,
-            ALPHA_MAX_SGIX = SGIX_blend_alpha_minmax.ALPHA_MAX_SGIX,
-            FUNC_REVERSE_SUBTRACT_EXT = EXT_blend_subtract.FUNC_REVERSE_SUBTRACT_EXT,
-            ALPHA_MIN_SGIX = SGIX_blend_alpha_minmax.ALPHA_MIN_SGIX,
-            MIN_EXT = EXT_blend_minmax.MIN_EXT,
-        }
-
-        public enum NV_multisample_filter_hint : uint
-        {
-            MULTISAMPLE_FILTER_HINT_NV = 0x8534,
-        }
-
-        public enum NV_texgen_emboss : uint
-        {
-            EMBOSS_CONSTANT_NV = 0x855E,
-            EMBOSS_LIGHT_NV = 0x855D,
-            EMBOSS_MAP_NV = 0x855F,
-        }
-
-        public enum NV_fragment_program_option : uint
-        {
-        }
-
-        public enum HP_image_transform : uint
-        {
-            IMAGE_TRANSFORM_2D_HP = 0x8161,
-            IMAGE_MIN_FILTER_HP = 0x815D,
-            IMAGE_TRANSLATE_Y_HP = 0x8158,
-            IMAGE_TRANSLATE_X_HP = 0x8157,
-            AVERAGE_HP = 0x8160,
-            POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162,
-            IMAGE_SCALE_Y_HP = 0x8156,
-            IMAGE_SCALE_X_HP = 0x8155,
-            CUBIC_HP = 0x815F,
-            IMAGE_MAG_FILTER_HP = 0x815C,
-            IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B,
-            IMAGE_ROTATE_ORIGIN_X_HP = 0x815A,
-            PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163,
-            IMAGE_CUBIC_WEIGHT_HP = 0x815E,
-            IMAGE_ROTATE_ANGLE_HP = 0x8159,
-        }
-
-        public enum NV_half_float : uint
-        {
-            HALF_FLOAT_NV = 0x140B,
-        }
-
-        public enum APPLE_vertex_array_range : uint
-        {
-            STORAGE_SHARED_APPLE = 0x85BF,
-            VERTEX_ARRAY_RANGE_APPLE = 0x851D,
-            VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F,
-            VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E,
-            VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521,
-            STORAGE_CACHED_APPLE = 0x85BE,
-        }
-
-        public enum NV_texture_compression_vtc : uint
-        {
-        }
-
-        public enum NV_texture_expand_normal : uint
-        {
-            TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F,
-        }
-
-        public enum S3_s3tc : uint
-        {
-            RGB4_S3TC = 0x83A1,
-            RGBA_S3TC = 0x83A2,
-            RGB_S3TC = 0x83A0,
-            RGBA4_S3TC = 0x83A3,
-        }
-
-        public enum ARB_fragment_shader : uint
-        {
-            MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49,
-            FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B,
-            FRAGMENT_SHADER_ARB = 0x8B30,
-        }
-
-        public enum TexCoordPointerType : uint
-        {
-            DOUBLE = DataType.DOUBLE,
-            INT = DataType.INT,
-            SHORT = DataType.SHORT,
-            FLOAT = DataType.FLOAT,
-        }
-
-        public enum ClearBufferMask : uint
-        {
-            STENCIL_BUFFER_BIT = AttribMask.STENCIL_BUFFER_BIT,
-            ACCUM_BUFFER_BIT = AttribMask.ACCUM_BUFFER_BIT,
-            COLOR_BUFFER_BIT = AttribMask.COLOR_BUFFER_BIT,
-            DEPTH_BUFFER_BIT = AttribMask.DEPTH_BUFFER_BIT,
-        }
-
-        public enum SGIX_ycrcb : uint
-        {
-            YCRCB_422_SGIX = 0x81BB,
-            YCRCB_444_SGIX = 0x81BC,
-        }
-
-        public enum EXT_rescale_normal : uint
-        {
-            RESCALE_NORMAL_EXT = 0x803A,
-            RESCALE_NORMAL = 0x803A,
-        }
-
-        public enum ARB_shader_objects : uint
-        {
-            OBJECT_VALIDATE_STATUS_ARB = 0x8B83,
-            BOOL_VEC3_ARB = 0x8B58,
-            SAMPLER_2D_RECT_ARB = 0x8B63,
-            OBJECT_COMPILE_STATUS_ARB = 0x8B81,
-            OBJECT_DELETE_STATUS_ARB = 0x8B80,
-            OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87,
-            FLOAT_MAT2_ARB = 0x8B5A,
-            BOOL_ARB = 0x8B56,
-            FLOAT_MAT4_ARB = 0x8B5C,
-            OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88,
-            SAMPLER_3D_ARB = 0x8B5F,
-            OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84,
-            INT_VEC4_ARB = 0x8B55,
-            FLOAT_MAT3_ARB = 0x8B5B,
-            PROGRAM_OBJECT_ARB = 0x8B40,
-            SAMPLER_1D_SHADOW_ARB = 0x8B61,
-            OBJECT_TYPE_ARB = 0x8B4E,
-            BOOL_VEC4_ARB = 0x8B59,
-            BOOL_VEC2_ARB = 0x8B57,
-            OBJECT_SUBTYPE_ARB = 0x8B4F,
-            SAMPLER_1D_ARB = 0x8B5D,
-            SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64,
-            SHADER_OBJECT_ARB = 0x8B48,
-            FLOAT_VEC2_ARB = 0x8B50,
-            SAMPLER_2D_SHADOW_ARB = 0x8B62,
-            OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85,
-            FLOAT_VEC4_ARB = 0x8B52,
-            OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86,
-            SAMPLER_CUBE_ARB = 0x8B60,
-            SAMPLER_2D_ARB = 0x8B5E,
-            INT_VEC2_ARB = 0x8B53,
-            OBJECT_LINK_STATUS_ARB = 0x8B82,
-            INT_VEC3_ARB = 0x8B54,
-            FLOAT_VEC3_ARB = 0x8B51,
-        }
-
-        public enum SGIX_shadow_ambient : uint
-        {
-            SHADOW_AMBIENT_SGIX = 0x80BF,
-        }
-
-        public enum SUNX_constant_data : uint
-        {
-            TEXTURE_CONSTANT_DATA_SUNX = 0x81D6,
-            UNPACK_CONSTANT_DATA_SUNX = 0x81D5,
-        }
-
-        public enum EXT_blend_minmax : uint
-        {
-            MAX_EXT = 0x8008,
-            BLEND_EQUATION_EXT = 0x8009,
-            MIN = 0x8007,
-            FUNC_ADD_EXT = 0x8006,
-            FUNC_ADD = 0x8006,
-            MAX = 0x8008,
-            MIN_EXT = 0x8007,
-            BLEND_EQUATION = 0x8009,
-        }
-
-        public enum EXT_packed_pixels : uint
-        {
-            UNSIGNED_BYTE_3_3_2 = 0x8032,
-            UNSIGNED_INT_2_10_10_10_REV = 0x8368,
-            UNSIGNED_INT_10_10_10_2 = 0x8036,
-            UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
-            UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364,
-            UNSIGNED_INT_8_8_8_8 = 0x8035,
-            UNSIGNED_SHORT_5_6_5 = 0x8363,
-            UNSIGNED_INT_8_8_8_8_REV = 0x8367,
-            UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
-            UNSIGNED_INT_8_8_8_8_EXT = 0x8035,
-            UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366,
-            UNSIGNED_SHORT_5_6_5_REV = 0x8364,
-            UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365,
-            UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368,
-            UNSIGNED_BYTE_2_3_3_REV = 0x8362,
-            UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362,
-            UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033,
-            UNSIGNED_INT_10_10_10_2_EXT = 0x8036,
-            UNSIGNED_SHORT_5_6_5_EXT = 0x8363,
-            UNSIGNED_SHORT_5_5_5_1 = 0x8034,
-            UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367,
-            UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034,
-            UNSIGNED_BYTE_3_3_2_EXT = 0x8032,
-            UNSIGNED_SHORT_4_4_4_4 = 0x8033,
-        }
-
-        public enum LightEnvParameterSGIX : uint
-        {
-            LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX,
-        }
-
-        public enum EXT_blend_color : uint
-        {
-            CONSTANT_COLOR_EXT = 0x8001,
-            CONSTANT_ALPHA = 0x8003,
-            BLEND_COLOR_EXT = 0x8005,
-            CONSTANT_ALPHA_EXT = 0x8003,
-            ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002,
-            ONE_MINUS_CONSTANT_COLOR = 0x8002,
-            ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004,
-            CONSTANT_COLOR = 0x8001,
-            BLEND_COLOR = 0x8005,
-            ONE_MINUS_CONSTANT_ALPHA = 0x8004,
-        }
-
-        public enum INTEL_texture_scissor : uint
-        {
-        }
-
-        public enum PixelTexGenMode : uint
-        {
-            RGB = PixelFormat.RGB,
-            NONE = DrawBufferMode.NONE,
-            LUMINANCE = PixelFormat.LUMINANCE,
-            PIXEL_TEX_GEN_ALPHA_MS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_MS_SGIX,
-            PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX,
-            PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX,
-            LUMINANCE_ALPHA = PixelFormat.LUMINANCE_ALPHA,
-            PIXEL_TEX_GEN_ALPHA_LS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_LS_SGIX,
-            RGBA = PixelFormat.RGBA,
-        }
-
-        public enum EXT_copy_texture : uint
-        {
-        }
-
-        public enum NV_light_max_exponent : uint
-        {
-            MAX_SPOT_EXPONENT_NV = 0x8505,
-            MAX_SHININESS_NV = 0x8504,
-        }
-
-        public enum EXT_depth_bounds_test : uint
-        {
-            DEPTH_BOUNDS_EXT = 0x8891,
-            DEPTH_BOUNDS_TEST_EXT = 0x8890,
-        }
-
-        public enum ARB_texture_float : uint
-        {
-            TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14,
-            TEXTURE_BLUE_TYPE_ARB = 0x8C12,
-            LUMINANCE_ALPHA32F_ARB = 0x8819,
-            TEXTURE_DEPTH_TYPE_ARB = 0x8C16,
-            RGB32F_ARB = 0x8815,
-            LUMINANCE16F_ARB = 0x881E,
-            TEXTURE_RED_TYPE_ARB = 0x8C10,
-            TEXTURE_GREEN_TYPE_ARB = 0x8C11,
-            ALPHA16F_ARB = 0x881C,
-            TEXTURE_INTENSITY_TYPE_ARB = 0x8C15,
-            INTENSITY32F_ARB = 0x8817,
-            TEXTURE_ALPHA_TYPE_ARB = 0x8C13,
-            INTENSITY16F_ARB = 0x881D,
-            LUMINANCE32F_ARB = 0x8818,
-            LUMINANCE_ALPHA16F_ARB = 0x881F,
-            RGBA16F_ARB = 0x881A,
-            RGB16F_ARB = 0x881B,
-            ALPHA32F_ARB = 0x8816,
-            UNSIGNED_NORMALIZED_ARB = 0x8C17,
-            RGBA32F_ARB = 0x8814,
-        }
-
-        public enum FogMode : uint
-        {
-            EXP2 = 0x0801,
-            EXP = 0x0800,
-            LINEAR = TextureMagFilter.LINEAR,
-            FOG_FUNC_SGIS = SGIS_fog_function.FOG_FUNC_SGIS,
-        }
-
-        public enum EXT_422_pixels : uint
-        {
-            _422_REV_EXT = 0x80CD,
-            _422_EXT = 0x80CC,
-            _422_REV_AVERAGE_EXT = 0x80CF,
-            _422_AVERAGE_EXT = 0x80CE,
-        }
-
-        public enum ColorTableParameterPNameSGI : uint
-        {
-            COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI,
-            COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI,
-        }
-
-        public enum SGIX_calligraphic_fragment : uint
-        {
-            CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183,
-        }
-
-        public enum SGIS_texture_border_clamp : uint
-        {
-            CLAMP_TO_BORDER_SGIS = 0x812D,
-            CLAMP_TO_BORDER_ARB = 0x812D,
-            CLAMP_TO_BORDER = 0x812D,
-        }
-
-        public enum ARB_texture_env_dot3 : uint
-        {
-            DOT3_RGB_ARB = 0x86AE,
-            DOT3_RGBA_ARB = 0x86AF,
-        }
-
-        public enum HintTarget : uint
-        {
-            GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS,
-            POLYGON_SMOOTH_HINT = GetPName.POLYGON_SMOOTH_HINT,
-            VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX,
-            LINE_SMOOTH_HINT = GetPName.LINE_SMOOTH_HINT,
-            POINT_SMOOTH_HINT = GetPName.POINT_SMOOTH_HINT,
-            PERSPECTIVE_CORRECTION_HINT = GetPName.PERSPECTIVE_CORRECTION_HINT,
-            UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT,
-            FOG_HINT = GetPName.FOG_HINT,
-            CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX,
-            TEXTURE_MULTI_BUFFER_HINT_SGIX = SGIX_texture_multi_buffer.TEXTURE_MULTI_BUFFER_HINT_SGIX,
-            PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT,
-        }
-
-        public enum MESA_resize_buffers : uint
-        {
-        }
-
-        public enum VERSION_1_4 : uint
-        {
-            DECR_WRAP = 0x8508,
-            GENERATE_MIPMAP = 0x8191,
-            FRAGMENT_DEPTH = 0x8452,
-            MAX_TEXTURE_LOD_BIAS = 0x84FD,
-            FOG_COORDINATE_ARRAY = 0x8457,
-            BLEND_DST_RGB = 0x80C8,
-            GENERATE_MIPMAP_HINT = 0x8192,
-            BLEND_SRC_ALPHA = 0x80CB,
-            TEXTURE_COMPARE_MODE = 0x884C,
-            FOG_COORDINATE_ARRAY_STRIDE = 0x8455,
-            TEXTURE_FILTER_CONTROL = 0x8500,
-            DEPTH_COMPONENT24 = 0x81A6,
-            FOG_COORDINATE_SOURCE = 0x8450,
-            POINT_SIZE_MAX = 0x8127,
-            POINT_DISTANCE_ATTENUATION = 0x8129,
-            SECONDARY_COLOR_ARRAY_SIZE = 0x845A,
-            DEPTH_TEXTURE_MODE = 0x884B,
-            DEPTH_COMPONENT16 = 0x81A5,
-            FOG_COORDINATE_ARRAY_TYPE = 0x8454,
-            MIRRORED_REPEAT = 0x8370,
-            CURRENT_SECONDARY_COLOR = 0x8459,
-            SECONDARY_COLOR_ARRAY_POINTER = 0x845D,
-            SECONDARY_COLOR_ARRAY_STRIDE = 0x845C,
-            DEPTH_COMPONENT32 = 0x81A7,
-            TEXTURE_COMPARE_FUNC = 0x884D,
-            TEXTURE_DEPTH_SIZE = 0x884A,
-            BLEND_DST_ALPHA = 0x80CA,
-            CURRENT_FOG_COORDINATE = 0x8453,
-            POINT_FADE_THRESHOLD_SIZE = 0x8128,
-            COMPARE_R_TO_TEXTURE = 0x884E,
-            TEXTURE_LOD_BIAS = 0x8501,
-            FOG_COORDINATE_ARRAY_POINTER = 0x8456,
-            BLEND_SRC_RGB = 0x80C9,
-            COLOR_SUM = 0x8458,
-            FOG_COORDINATE = 0x8451,
-            SECONDARY_COLOR_ARRAY_TYPE = 0x845B,
-            POINT_SIZE_MIN = 0x8126,
-            INCR_WRAP = 0x8507,
-            SECONDARY_COLOR_ARRAY = 0x845E,
-        }
-
-        public enum LightName : uint
-        {
-            FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX,
-            FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX,
-            LIGHT4 = 0x4004,
-            LIGHT3 = 0x4003,
-            FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX,
-            LIGHT6 = 0x4006,
-            FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX,
-            LIGHT5 = 0x4005,
-            LIGHT0 = 0x4000,
-            FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX,
-            FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX,
-            LIGHT7 = 0x4007,
-            LIGHT2 = 0x4002,
-            FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
-            LIGHT1 = 0x4001,
-            FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX,
-        }
-
-        public enum SGIS_point_parameters : uint
-        {
-            POINT_SIZE_MIN_SGIS = 0x8126,
-            POINT_SIZE_MAX_SGIS = 0x8127,
-            POINT_DISTANCE_ATTENUATION = 0x8129,
-            DISTANCE_ATTENUATION_EXT = 0x8129,
-            POINT_FADE_THRESHOLD_SIZE = 0x8128,
-            POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128,
-            POINT_SIZE_MIN_EXT = 0x8126,
-            POINT_SIZE_MAX = 0x8127,
-            POINT_DISTANCE_ATTENUATION_ARB = 0x8129,
-            POINT_SIZE_MIN = 0x8126,
-            POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128,
-            DISTANCE_ATTENUATION_SGIS = 0x8129,
-            POINT_SIZE_MAX_EXT = 0x8127,
-            POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128,
-            POINT_SIZE_MAX_ARB = 0x8127,
-            POINT_SIZE_MIN_ARB = 0x8126,
-        }
-
-        public enum EXT_packed_depth_stencil : uint
-        {
-            DEPTH_STENCIL_EXT = 0x84F9,
-            TEXTURE_STENCIL_SIZE_EXT = 0x88F1,
-            UNSIGNED_INT_24_8_EXT = 0x84FA,
-            DEPTH24_STENCIL8_EXT = 0x88F0,
-        }
-
-        public enum EXT_color_subtable : uint
-        {
-        }
-
-        public enum MESA_ycbcr_texture : uint
-        {
-            UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB,
-            YCBCR_MESA = 0x8757,
-            UNSIGNED_SHORT_8_8_MESA = 0x85BA,
-        }
-
-        public enum SGIX_shadow : uint
-        {
-            TEXTURE_LEQUAL_R_SGIX = 0x819C,
-            TEXTURE_COMPARE_SGIX = 0x819A,
-            TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B,
-            TEXTURE_GEQUAL_R_SGIX = 0x819D,
-        }
-
-        public enum ARB_texture_mirrored_repeat : uint
-        {
-            MIRRORED_REPEAT_ARB = 0x8370,
-        }
-
-        public enum EXT_texture_object : uint
-        {
-            TEXTURE_2D_BINDING_EXT = 0x8069,
-            TEXTURE_1D_BINDING_EXT = 0x8068,
-            TEXTURE_PRIORITY_EXT = 0x8066,
-            TEXTURE_3D_BINDING_EXT = 0x806A,
-            TEXTURE_RESIDENT_EXT = 0x8067,
-        }
-
-        public enum EXT_texture_filter_anisotropic : uint
-        {
-            TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE,
-            MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF,
-        }
-
-        public enum SGIS_multisample : uint
-        {
-            SAMPLE_PATTERN_SGIS = 0x80AC,
-            _1PASS_SGIS = 0x80A1,
-            _2PASS_1_SGIS = 0x80A3,
-            _2PASS_0_SGIS = 0x80A2,
-            _4PASS_3_SGIS = 0x80A7,
-            _4PASS_0_SGIS = 0x80A4,
-            SAMPLE_MASK_SGIS = 0x80A0,
-            _4PASS_1_SGIS = 0x80A5,
-            SAMPLES_SGIS = 0x80A9,
-            MULTISAMPLE_SGIS = 0x809D,
-            SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E,
-            _4PASS_2_SGIS = 0x80A6,
-            SAMPLE_MASK_INVERT_SGIS = 0x80AB,
-            SAMPLE_BUFFERS_SGIS = 0x80A8,
-            SAMPLE_MASK_VALUE_SGIS = 0x80AA,
-            SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F,
-        }
-
-        public enum GetPixelMap : uint
-        {
-            PIXEL_MAP_B_TO_B = 0x0C78,
-            PIXEL_MAP_S_TO_S = 0x0C71,
-            PIXEL_MAP_R_TO_R = 0x0C76,
-            PIXEL_MAP_I_TO_B = 0x0C74,
-            PIXEL_MAP_I_TO_G = 0x0C73,
-            PIXEL_MAP_I_TO_A = 0x0C75,
-            PIXEL_MAP_A_TO_A = 0x0C79,
-            PIXEL_MAP_G_TO_G = 0x0C77,
-            PIXEL_MAP_I_TO_I = 0x0C70,
-            PIXEL_MAP_I_TO_R = 0x0C72,
-        }
-
-        public enum EXT_pixel_transform : uint
-        {
-            PIXEL_MIN_FILTER_EXT = 0x8332,
-            PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336,
-            PIXEL_TRANSFORM_2D_EXT = 0x8330,
-            MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337,
-            CUBIC_EXT = 0x8334,
-            PIXEL_CUBIC_WEIGHT_EXT = 0x8333,
-            AVERAGE_EXT = 0x8335,
-            PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338,
-            PIXEL_MAG_FILTER_EXT = 0x8331,
-        }
-
-        public enum PGI_vertex_hints : uint
-        {
-            MAT_SPECULAR_BIT_PGI = 0x04000000,
-            TEXCOORD2_BIT_PGI = 0x20000000,
-            VERTEX_CONSISTENT_HINT_PGI = 0x1A22B,
-            MAT_SHININESS_BIT_PGI = 0x02000000,
-            MAT_AMBIENT_BIT_PGI = 0x00100000,
-            MATERIAL_SIDE_HINT_PGI = 0x1A22C,
-            TEXCOORD3_BIT_PGI = 0x40000000,
-            TEXCOORD4_BIT_PGI = 0x80000000,
-            MAT_COLOR_INDEXES_BIT_PGI = 0x01000000,
-            MAX_VERTEX_HINT_PGI = 0x1A22D,
-            VERTEX23_BIT_PGI = 0x00000004,
-            TEXCOORD1_BIT_PGI = 0x10000000,
-            INDEX_BIT_PGI = 0x00080000,
-            EDGEFLAG_BIT_PGI = 0x00040000,
-            COLOR3_BIT_PGI = 0x00010000,
-            VERTEX_DATA_HINT_PGI = 0x1A22A,
-            MAT_DIFFUSE_BIT_PGI = 0x00400000,
-            NORMAL_BIT_PGI = 0x08000000,
-            MAT_EMISSION_BIT_PGI = 0x00800000,
-            COLOR4_BIT_PGI = 0x00020000,
-            VERTEX4_BIT_PGI = 0x00000008,
-            MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000,
-        }
-
-        public enum LightModelParameter : uint
-        {
-            LIGHT_MODEL_LOCAL_VIEWER = GetPName.LIGHT_MODEL_LOCAL_VIEWER,
-            LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL,
-            LIGHT_MODEL_AMBIENT = GetPName.LIGHT_MODEL_AMBIENT,
-            LIGHT_MODEL_TWO_SIDE = GetPName.LIGHT_MODEL_TWO_SIDE,
-        }
-
-        public enum NV_register_combiners : uint
-        {
-            COMBINER_MAPPING_NV = 0x8543,
-            SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532,
-            COMBINER_CD_OUTPUT_NV = 0x854B,
-            ZERO = BlendingFactorDest.ZERO,
-            COMBINER_INPUT_NV = 0x8542,
-            COMBINER5_NV = 0x8555,
-            SIGNED_NEGATE_NV = 0x853D,
-            COMBINER_SUM_OUTPUT_NV = 0x854C,
-            SCALE_BY_TWO_NV = 0x853E,
-            REGISTER_COMBINERS_NV = 0x8522,
-            COMBINER6_NV = 0x8556,
-            SCALE_BY_FOUR_NV = 0x853F,
-            E_TIMES_F_NV = 0x8531,
-            PRIMARY_COLOR_NV = 0x852C,
-            COMBINER2_NV = 0x8552,
-            COMBINER3_NV = 0x8553,
-            COMBINER0_NV = 0x8550,
-            COMBINER1_NV = 0x8551,
-            VARIABLE_F_NV = 0x8528,
-            FOG = GetPName.FOG,
-            SIGNED_IDENTITY_NV = 0x853C,
-            SECONDARY_COLOR_NV = 0x852D,
-            SCALE_BY_ONE_HALF_NV = 0x8540,
-            COMBINER_AB_OUTPUT_NV = 0x854A,
-            NONE = DrawBufferMode.NONE,
-            CONSTANT_COLOR0_NV = 0x852A,
-            COMBINER_CD_DOT_PRODUCT_NV = 0x8546,
-            TEXTURE0_ARB = ARB_multitexture.TEXTURE0_ARB,
-            UNSIGNED_INVERT_NV = 0x8537,
-            NUM_GENERAL_COMBINERS_NV = 0x854E,
-            COMBINER_BIAS_NV = 0x8549,
-            VARIABLE_B_NV = 0x8524,
-            EXPAND_NORMAL_NV = 0x8538,
-            VARIABLE_C_NV = 0x8525,
-            HALF_BIAS_NORMAL_NV = 0x853A,
-            COMBINER_COMPONENT_USAGE_NV = 0x8544,
-            COMBINER_SCALE_NV = 0x8548,
-            VARIABLE_A_NV = 0x8523,
-            HALF_BIAS_NEGATE_NV = 0x853B,
-            DISCARD_NV = 0x8530,
-            COMBINER_AB_DOT_PRODUCT_NV = 0x8545,
-            UNSIGNED_IDENTITY_NV = 0x8536,
-            EXPAND_NEGATE_NV = 0x8539,
-            VARIABLE_D_NV = 0x8526,
-            BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541,
-            VARIABLE_E_NV = 0x8527,
-            COMBINER_MUX_SUM_NV = 0x8547,
-            MAX_GENERAL_COMBINERS_NV = 0x854D,
-            COMBINER7_NV = 0x8557,
-            COMBINER4_NV = 0x8554,
-            COLOR_SUM_CLAMP_NV = 0x854F,
-            TEXTURE1_ARB = ARB_multitexture.TEXTURE1_ARB,
-            SPARE1_NV = 0x852F,
-            CONSTANT_COLOR1_NV = 0x852B,
-            SPARE0_NV = 0x852E,
-            VARIABLE_G_NV = 0x8529,
-        }
-
-        public enum ATI_vertex_attrib_array_object : uint
-        {
-        }
-
-        public enum NV_vertex_array_range2 : uint
-        {
-            VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533,
-        }
-
-        public enum ARB_half_float_pixel : uint
-        {
-            HALF_FLOAT_ARB = 0x140B,
-        }
-
-        public enum EXT_separate_specular_color : uint
-        {
-            SINGLE_COLOR_EXT = 0x81F9,
-            LIGHT_MODEL_COLOR_CONTROL = 0x81F8,
-            SEPARATE_SPECULAR_COLOR_EXT = 0x81FA,
-            LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8,
-            SEPARATE_SPECULAR_COLOR = 0x81FA,
-            SINGLE_COLOR = 0x81F9,
-        }
-
-        public enum EXT_blend_logic_op : uint
-        {
-        }
-
-        public enum ATI_envmap_bumpmap : uint
-        {
-            BUMP_TARGET_ATI = 0x877C,
-            BUMP_ROT_MATRIX_ATI = 0x8775,
-            DU8DV8_ATI = 0x877A,
-            BUMP_NUM_TEX_UNITS_ATI = 0x8777,
-            BUMP_ROT_MATRIX_SIZE_ATI = 0x8776,
-            BUMP_ENVMAP_ATI = 0x877B,
-            BUMP_TEX_UNITS_ATI = 0x8778,
-            DUDV_ATI = 0x8779,
-        }
-
-        public enum ATI_draw_buffers : uint
-        {
-            DRAW_BUFFER9_ATI = 0x882E,
-            DRAW_BUFFER10_ATI = 0x882F,
-            DRAW_BUFFER6_ATI = 0x882B,
-            DRAW_BUFFER4_ATI = 0x8829,
-            DRAW_BUFFER14_ATI = 0x8833,
-            DRAW_BUFFER3_ATI = 0x8828,
-            DRAW_BUFFER5_ATI = 0x882A,
-            DRAW_BUFFER0_ATI = 0x8825,
-            DRAW_BUFFER12_ATI = 0x8831,
-            DRAW_BUFFER11_ATI = 0x8830,
-            DRAW_BUFFER8_ATI = 0x882D,
-            DRAW_BUFFER15_ATI = 0x8834,
-            DRAW_BUFFER7_ATI = 0x882C,
-            DRAW_BUFFER13_ATI = 0x8832,
-            DRAW_BUFFER2_ATI = 0x8827,
-            DRAW_BUFFER1_ATI = 0x8826,
-            MAX_DRAW_BUFFERS_ATI = 0x8824,
-        }
-
-        public enum ColorMaterialFace : uint
-        {
-            BACK = DrawBufferMode.BACK,
-            FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
-            FRONT = DrawBufferMode.FRONT,
-        }
-
-        public enum GetTextureParameter : uint
-        {
-            TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX,
-            TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT,
-            TEXTURE_BORDER = 0x1005,
-            TEXTURE_HEIGHT = 0x1001,
-            TEXTURE_INTENSITY_SIZE = 0x8061,
-            TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX,
-            TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS,
-            TEXTURE_FILTER4_SIZE_SGIS = SGIS_texture_filter4.TEXTURE_FILTER4_SIZE_SGIS,
-            TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX,
-            TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX,
-            TEXTURE_PRIORITY = 0x8066,
-            TEXTURE_RED_SIZE = 0x805C,
-            TEXTURE_MIN_FILTER = TextureParameterName.TEXTURE_MIN_FILTER,
-            TEXTURE_4DSIZE_SGIS = SGIS_texture4D.TEXTURE_4DSIZE_SGIS,
-            TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS,
-            TEXTURE_WIDTH = 0x1000,
-            TEXTURE_BLUE_SIZE = 0x805E,
-            TEXTURE_WRAP_T = TextureParameterName.TEXTURE_WRAP_T,
-            TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS,
-            POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX,
-            TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX,
-            TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX,
-            TEXTURE_INTERNAL_FORMAT = 0x1003,
-            TEXTURE_LUMINANCE_SIZE = 0x8060,
-            TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX,
-            DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS,
-            TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX,
-            TEXTURE_COMPONENTS = 0x1003,
-            TEXTURE_COMPARE_OPERATOR_SGIX = SGIX_shadow.TEXTURE_COMPARE_OPERATOR_SGIX,
-            TEXTURE_LEQUAL_R_SGIX = SGIX_shadow.TEXTURE_LEQUAL_R_SGIX,
-            TEXTURE_GEQUAL_R_SGIX = SGIX_shadow.TEXTURE_GEQUAL_R_SGIX,
-            TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX,
-            DETAIL_TEXTURE_FUNC_POINTS_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_FUNC_POINTS_SGIS,
-            DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS,
-            TEXTURE_BORDER_COLOR = 0x1004,
-            SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX,
-            TEXTURE_MAG_FILTER = TextureParameterName.TEXTURE_MAG_FILTER,
-            TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS,
-            TEXTURE_GREEN_SIZE = 0x805D,
-            TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS,
-            TEXTURE_WRAP_S = TextureParameterName.TEXTURE_WRAP_S,
-            TEXTURE_RESIDENT = 0x8067,
-            TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX,
-            POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX,
-            DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS,
-            TEXTURE_DEPTH_EXT = EXT_texture3D.TEXTURE_DEPTH_EXT,
-            TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX,
-            TEXTURE_ALPHA_SIZE = 0x805F,
-            TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX,
-            QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS,
-            GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS,
-            SHARPEN_TEXTURE_FUNC_POINTS_SGIS = SGIS_sharpen_texture.SHARPEN_TEXTURE_FUNC_POINTS_SGIS,
-            TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX,
-        }
-
-        public enum ARB_texture_env_combine : uint
-        {
-            SOURCE2_RGB_ARB = 0x8582,
-            OPERAND0_ALPHA_ARB = 0x8598,
-            COMBINE_ARB = 0x8570,
-            SOURCE1_RGB_ARB = 0x8581,
-            ADD_SIGNED_ARB = 0x8574,
-            SUBTRACT_ARB = 0x84E7,
-            PRIMARY_COLOR_ARB = 0x8577,
-            SOURCE2_ALPHA_ARB = 0x858A,
-            OPERAND1_RGB_ARB = 0x8591,
-            OPERAND0_RGB_ARB = 0x8590,
-            OPERAND2_ALPHA_ARB = 0x859A,
-            CONSTANT_ARB = 0x8576,
-            SOURCE0_ALPHA_ARB = 0x8588,
-            INTERPOLATE_ARB = 0x8575,
-            PREVIOUS_ARB = 0x8578,
-            OPERAND2_RGB_ARB = 0x8592,
-            COMBINE_RGB_ARB = 0x8571,
-            SOURCE1_ALPHA_ARB = 0x8589,
-            SOURCE0_RGB_ARB = 0x8580,
-            COMBINE_ALPHA_ARB = 0x8572,
-            OPERAND1_ALPHA_ARB = 0x8599,
-            RGB_SCALE_ARB = 0x8573,
-        }
-
-        public enum SUN_global_alpha : uint
-        {
-            GLOBAL_ALPHA_SUN = 0x81D9,
-            GLOBAL_ALPHA_FACTOR_SUN = 0x81DA,
-        }
-
-        public enum NV_texture_shader : uint
-        {
-            DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA,
-            DS_SCALE_NV = 0x8710,
-            DSDT_MAG_INTENSITY_NV = 0x86DC,
-            SIGNED_HILO_NV = 0x86F9,
-            DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9,
-            OFFSET_TEXTURE_SCALE_NV = 0x86E2,
-            MAGNITUDE_SCALE_NV = 0x8712,
-            CULL_FRAGMENT_NV = 0x86E7,
-            OFFSET_TEXTURE_2D_SCALE_NV = NV_texture_shader.OFFSET_TEXTURE_SCALE_NV,
-            TEXTURE_DT_SIZE_NV = 0x871E,
-            OFFSET_TEXTURE_2D_NV = 0x86E8,
-            UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA,
-            VIBRANCE_SCALE_NV = 0x8713,
-            PREVIOUS_TEXTURE_INPUT_NV = 0x86E4,
-            SIGNED_LUMINANCE_NV = 0x8701,
-            DS_BIAS_NV = 0x8716,
-            SIGNED_RGB8_NV = 0x86FF,
-            DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1,
-            DSDT8_MAG8_INTENSITY8_NV = 0x870B,
-            VIBRANCE_BIAS_NV = 0x8719,
-            SIGNED_ALPHA8_NV = 0x8706,
-            LO_BIAS_NV = 0x8715,
-            UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB,
-            DOT_PRODUCT_NV = 0x86EC,
-            DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE,
-            SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D,
-            DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E,
-            DT_BIAS_NV = 0x8717,
-            SIGNED_LUMINANCE_ALPHA_NV = 0x8703,
-            OFFSET_TEXTURE_BIAS_NV = 0x86E3,
-            OFFSET_TEXTURE_2D_MATRIX_NV = NV_texture_shader.OFFSET_TEXTURE_MATRIX_NV,
-            HILO16_NV = 0x86F8,
-            TEXTURE_BORDER_VALUES_NV = 0x871A,
-            SIGNED_ALPHA_NV = 0x8705,
-            OFFSET_TEXTURE_MATRIX_NV = 0x86E1,
-            TEXTURE_SHADER_NV = 0x86DE,
-            OFFSET_TEXTURE_RECTANGLE_NV = 0x864C,
-            HI_BIAS_NV = 0x8714,
-            DSDT8_NV = 0x8709,
-            SHADER_CONSISTENT_NV = 0x86DD,
-            DSDT_MAG_NV = 0x86F6,
-            TEXTURE_LO_SIZE_NV = 0x871C,
-            DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2,
-            DSDT8_MAG8_NV = 0x870A,
-            SIGNED_RGBA8_NV = 0x86FC,
-            DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0,
-            CULL_MODES_NV = 0x86E0,
-            SIGNED_RGB_NV = 0x86FE,
-            OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D,
-            DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED,
-            CONST_EYE_NV = 0x86E5,
-            SIGNED_RGBA_NV = 0x86FB,
-            RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9,
-            SIGNED_INTENSITY8_NV = 0x8708,
-            SHADER_OPERATION_NV = 0x86DF,
-            PASS_THROUGH_NV = 0x86E6,
-            DSDT_NV = 0x86F5,
-            SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C,
-            OFFSET_TEXTURE_2D_BIAS_NV = NV_texture_shader.OFFSET_TEXTURE_BIAS_NV,
-            TEXTURE_MAG_SIZE_NV = 0x871F,
-            SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704,
-            SIGNED_HILO16_NV = 0x86FA,
-            SIGNED_INTENSITY_NV = 0x8707,
-            HILO_NV = 0x86F4,
-            DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3,
-            LO_SCALE_NV = 0x870F,
-            MAGNITUDE_BIAS_NV = 0x8718,
-            HI_SCALE_NV = 0x870E,
-            TEXTURE_DS_SIZE_NV = 0x871D,
-            DT_SCALE_NV = 0x8711,
-            SIGNED_LUMINANCE8_NV = 0x8702,
-            DSDT_MAG_VIB_NV = 0x86F7,
-            TEXTURE_HI_SIZE_NV = 0x871B,
-        }
-
-        public enum EXT_cull_vertex : uint
-        {
-            CULL_VERTEX_EXT = 0x81AA,
-            CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC,
-            CULL_VERTEX_EYE_POSITION_EXT = 0x81AB,
-        }
-
-        public enum ARB_texture_border_clamp : uint
-        {
-            CLAMP_TO_BORDER_ARB = 0x812D,
-        }
-
-        public enum SGIX_clipmap : uint
-        {
-            TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175,
-            NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E,
-            LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170,
-            TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172,
-            NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D,
-            TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174,
-            MAX_CLIPMAP_DEPTH_SGIX = 0x8177,
-            TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173,
-            TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176,
-            TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171,
-            LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F,
-            MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178,
-        }
-
-        public enum ConvolutionParameterEXT : uint
-        {
-            CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT,
-            CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT,
-            CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT,
-        }
-
-        public enum GetConvolutionParameter : uint
-        {
-            MAX_CONVOLUTION_WIDTH_EXT = EXT_convolution.MAX_CONVOLUTION_WIDTH_EXT,
-            CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT,
-            CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT,
-            CONVOLUTION_HEIGHT_EXT = EXT_convolution.CONVOLUTION_HEIGHT_EXT,
-            CONVOLUTION_WIDTH_EXT = EXT_convolution.CONVOLUTION_WIDTH_EXT,
-            MAX_CONVOLUTION_HEIGHT_EXT = EXT_convolution.MAX_CONVOLUTION_HEIGHT_EXT,
-            CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT,
-            CONVOLUTION_FORMAT_EXT = EXT_convolution.CONVOLUTION_FORMAT_EXT,
-        }
-
-        public enum SGIX_tag_sample_buffer : uint
-        {
-        }
-
-        public enum ClientAttribMask : uint
-        {
-            CLIENT_PIXEL_STORE_BIT = 0x00000001,
-            CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF,
-            CLIENT_VERTEX_ARRAY_BIT = 0x00000002,
-        }
-
-        public enum INGR_interlace_read : uint
-        {
-            INTERLACE_READ_INGR = 0x8568,
-        }
-
-        public enum ARB_texture_compression : uint
-        {
-            COMPRESSED_LUMINANCE_ARB = 0x84EA,
-            COMPRESSED_INTENSITY_ARB = 0x84EC,
-            TEXTURE_COMPRESSION_HINT_ARB = 0x84EF,
-            TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0,
-            COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3,
-            COMPRESSED_RGB_ARB = 0x84ED,
-            NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2,
-            COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB,
-            TEXTURE_COMPRESSED_ARB = 0x86A1,
-            COMPRESSED_ALPHA_ARB = 0x84E9,
-            COMPRESSED_RGBA_ARB = 0x84EE,
-        }
-
-        public enum TextureCoordName : uint
-        {
-            Q = 0x2003,
-            R = 0x2002,
-            S = 0x2000,
-            T = 0x2001,
-        }
-
-        public enum InterleavedArrayFormat : uint
-        {
-            T2F_C4UB_V3F = 0x2A29,
-            T2F_N3F_V3F = 0x2A2B,
-            T4F_V4F = 0x2A28,
-            T2F_V3F = 0x2A27,
-            V2F = 0x2A20,
-            T2F_C4F_N3F_V3F = 0x2A2C,
-            T4F_C4F_N3F_V4F = 0x2A2D,
-            T2F_C3F_V3F = 0x2A2A,
-            C3F_V3F = 0x2A24,
-            C4F_N3F_V3F = 0x2A26,
-            V3F = 0x2A21,
-            N3F_V3F = 0x2A25,
-            C4UB_V2F = 0x2A22,
-            C4UB_V3F = 0x2A23,
-        }
-
-        public enum NV_texture_shader3 : uint
-        {
-            DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859,
-            DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D,
-            SIGNED_HILO8_NV = 0x885F,
-            FORCE_BLUE_TO_ONE_NV = 0x8860,
-            OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857,
-            OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853,
-            DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858,
-            HILO8_NV = 0x885E,
-            OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850,
-            DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A,
-            OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856,
-            OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851,
-            OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855,
-            OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852,
-            OFFSET_HILO_TEXTURE_2D_NV = 0x8854,
-            DOT_PRODUCT_PASS_THROUGH_NV = 0x885B,
-            DOT_PRODUCT_TEXTURE_1D_NV = 0x885C,
-        }
-
-        public enum ARB_vertex_buffer_object : uint
-        {
-            NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897,
-            READ_ONLY_ARB = 0x88B8,
-            STATIC_DRAW_ARB = 0x88E4,
-            STATIC_COPY_ARB = 0x88E6,
-            BUFFER_MAP_POINTER_ARB = 0x88BD,
-            STREAM_COPY_ARB = 0x88E2,
-            STATIC_READ_ARB = 0x88E5,
-            READ_WRITE_ARB = 0x88BA,
-            TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A,
-            ARRAY_BUFFER_ARB = 0x8892,
-            BUFFER_SIZE_ARB = 0x8764,
-            BUFFER_ACCESS_ARB = 0x88BB,
-            DYNAMIC_DRAW_ARB = 0x88E8,
-            WRITE_ONLY_ARB = 0x88B9,
-            VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896,
-            FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D,
-            DYNAMIC_READ_ARB = 0x88E9,
-            DYNAMIC_COPY_ARB = 0x88EA,
-            STREAM_DRAW_ARB = 0x88E0,
-            WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E,
-            STREAM_READ_ARB = 0x88E1,
-            COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898,
-            BUFFER_MAPPED_ARB = 0x88BC,
-            INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899,
-            ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895,
-            EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B,
-            VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F,
-            ARRAY_BUFFER_BINDING_ARB = 0x8894,
-            SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C,
-            BUFFER_USAGE_ARB = 0x8765,
-            ELEMENT_ARRAY_BUFFER_ARB = 0x8893,
-        }
-
-        public enum SGIX_pixel_tiles : uint
-        {
-            PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F,
-            PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142,
-            PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143,
-            PIXEL_TILE_HEIGHT_SGIX = 0x8141,
-            PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145,
-            PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E,
-            PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144,
-            PIXEL_TILE_WIDTH_SGIX = 0x8140,
-        }
-
-        public enum NV_fragment_program2 : uint
-        {
-            MAX_PROGRAM_IF_DEPTH_NV = 0x88F6,
-            MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7,
-            MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5,
-            MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4,
-            MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8,
-        }
-
-        public enum EXT_vertex_weighting : uint
-        {
-            CURRENT_VERTEX_WEIGHT_EXT = 0x850B,
-            MODELVIEW0_MATRIX_EXT = GetPName.MODELVIEW_MATRIX,
-            VERTEX_WEIGHT_ARRAY_EXT = 0x850C,
-            MODELVIEW1_MATRIX_EXT = 0x8506,
-            VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E,
-            VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F,
-            MODELVIEW1_EXT = 0x850A,
-            VERTEX_WEIGHTING_EXT = 0x8509,
-            MODELVIEW0_EXT = MatrixMode.MODELVIEW,
-            MODELVIEW1_STACK_DEPTH_EXT = 0x8502,
-            VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510,
-            VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D,
-            MODELVIEW0_STACK_DEPTH_EXT = GetPName.MODELVIEW_STACK_DEPTH,
-        }
-
-        public enum ATI_pn_triangles : uint
-        {
-            PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4,
-            PN_TRIANGLES_POINT_MODE_ATI = 0x87F2,
-            PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8,
-            PN_TRIANGLES_ATI = 0x87F0,
-            PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7,
-            PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6,
-            PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3,
-            MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1,
-            PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5,
-        }
-
-        public enum SGIX_texture_scale_bias : uint
-        {
-            POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B,
-            POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179,
-            POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A,
-            POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C,
-        }
-
-        public enum SGIX_fog_offset : uint
-        {
-            FOG_OFFSET_VALUE_SGIX = 0x8199,
-            FOG_OFFSET_SGIX = 0x8198,
-        }
-
-        public enum EXT_texture : uint
-        {
-            LUMINANCE8_ALPHA8_EXT = 0x8045,
-            RGBA12_EXT = 0x805A,
-            INTENSITY12_EXT = 0x804C,
-            RGB16_EXT = 0x8054,
-            REPLACE_EXT = 0x8062,
-            RGB5_A1_EXT = 0x8057,
-            RGB5_EXT = 0x8050,
-            TEXTURE_INTENSITY_SIZE_EXT = 0x8061,
-            ALPHA12_EXT = 0x803D,
-            RGB4_EXT = 0x804F,
-            TEXTURE_LUMINANCE_SIZE_EXT = 0x8060,
-            RGBA16_EXT = 0x805B,
-            RGB8_EXT = 0x8051,
-            RGBA8_EXT = 0x8058,
-            RGB12_EXT = 0x8053,
-            LUMINANCE12_ALPHA12_EXT = 0x8047,
-            INTENSITY4_EXT = 0x804A,
-            INTENSITY8_EXT = 0x804B,
-            RGB10_A2_EXT = 0x8059,
-            RGB10_EXT = 0x8052,
-            LUMINANCE8_EXT = 0x8040,
-            TEXTURE_RED_SIZE_EXT = 0x805C,
-            LUMINANCE12_EXT = 0x8041,
-            PROXY_TEXTURE_2D_EXT = 0x8064,
-            LUMINANCE4_EXT = 0x803F,
-            INTENSITY16_EXT = 0x804D,
-            TEXTURE_GREEN_SIZE_EXT = 0x805D,
-            LUMINANCE16_ALPHA16_EXT = 0x8048,
-            TEXTURE_ALPHA_SIZE_EXT = 0x805F,
-            LUMINANCE16_EXT = 0x8042,
-            PROXY_TEXTURE_1D_EXT = 0x8063,
-            RGBA4_EXT = 0x8056,
-            INTENSITY_EXT = 0x8049,
-            RGBA2_EXT = 0x8055,
-            ALPHA16_EXT = 0x803E,
-            TEXTURE_TOO_LARGE_EXT = 0x8065,
-            ALPHA8_EXT = 0x803C,
-            ALPHA4_EXT = 0x803B,
-            LUMINANCE4_ALPHA4_EXT = 0x8043,
-            LUMINANCE6_ALPHA2_EXT = 0x8044,
-            TEXTURE_BLUE_SIZE_EXT = 0x805E,
-            RGB2_EXT = 0x804E,
-            LUMINANCE12_ALPHA4_EXT = 0x8046,
-        }
-
-        public enum IBM_rasterpos_clip : uint
-        {
-            RASTER_POSITION_UNCLIPPED_IBM = 0x19262,
-        }
-
-        public enum SGIS_texture_edge_clamp : uint
-        {
-            CLAMP_TO_EDGE_SGIS = 0x812F,
-            CLAMP_TO_EDGE = 0x812F,
-        }
-
-        public enum DataType : uint
-        {
-            DOUBLE = 0x140A,
-            DOUBLE_EXT = 0x140A,
-            UNSIGNED_INT = 0x1405,
-            _4_BYTES = 0x1409,
-            FLOAT = 0x1406,
-            UNSIGNED_SHORT = 0x1403,
-            SHORT = 0x1402,
-            BYTE = 0x1400,
-            _3_BYTES = 0x1408,
-            INT = 0x1404,
-            UNSIGNED_BYTE = 0x1401,
-            _2_BYTES = 0x1407,
-        }
-
-        public enum APPLE_fence : uint
-        {
-            DRAW_PIXELS_APPLE = 0x8A0A,
-            FENCE_APPLE = 0x8A0B,
-        }
-
-        public enum MeshMode1 : uint
-        {
-            LINE = PolygonMode.LINE,
-            POINT = PolygonMode.POINT,
-        }
-
-        public enum TextureTarget : uint
-        {
-            TEXTURE_1D = GetPName.TEXTURE_1D,
-            TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS,
-            TEXTURE_2D = GetPName.TEXTURE_2D,
-            TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS,
-            PROXY_TEXTURE_4D_SGIS = SGIS_texture4D.PROXY_TEXTURE_4D_SGIS,
-            PROXY_TEXTURE_2D = 0x8064,
-            TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
-            DETAIL_TEXTURE_2D_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_SGIS,
-            PROXY_TEXTURE_1D = 0x8063,
-            TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS,
-            TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS,
-            TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
-            PROXY_TEXTURE_3D_EXT = EXT_texture3D.PROXY_TEXTURE_3D_EXT,
-        }
-
-        public enum MeshMode2 : uint
-        {
-            FILL = PolygonMode.FILL,
-            LINE = PolygonMode.LINE,
-            POINT = PolygonMode.POINT,
-        }
-
-        public enum EXT_pixel_buffer_object : uint
-        {
-            PIXEL_UNPACK_BUFFER_EXT = 0x88EC,
-            PIXEL_PACK_BUFFER_EXT = 0x88EB,
-            PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF,
-            PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED,
-        }
-
-        public enum EXT_framebuffer_multisample : uint
-        {
-            RENDERBUFFER_SAMPLES_EXT = 0x8CAB,
-        }
-
-        public enum ATI_texture_mirror_once : uint
-        {
-            MIRROR_CLAMP_ATI = 0x8742,
-            MIRROR_CLAMP_TO_EDGE_ATI = 0x8743,
-        }
-
-        public enum SGI_color_table : uint
-        {
-            COLOR_TABLE_SGI = 0x80D0,
-            COLOR_TABLE_FORMAT_SGI = 0x80D8,
-            COLOR_TABLE_SCALE = 0x80D6,
-            COLOR_TABLE_SCALE_SGI = 0x80D6,
-            PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5,
-            COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF,
-            COLOR_TABLE_WIDTH_SGI = 0x80D9,
-            COLOR_TABLE_BIAS = 0x80D7,
-            COLOR_TABLE_BLUE_SIZE = 0x80DC,
-            POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2,
-            COLOR_TABLE_FORMAT = 0x80D8,
-            PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
-            PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4,
-            PROXY_COLOR_TABLE_SGI = 0x80D3,
-            COLOR_TABLE_GREEN_SIZE = 0x80DB,
-            PROXY_COLOR_TABLE = 0x80D3,
-            COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE,
-            COLOR_TABLE_ALPHA_SIZE = 0x80DD,
-            POST_CONVOLUTION_COLOR_TABLE = 0x80D1,
-            COLOR_TABLE_BIAS_SGI = 0x80D7,
-            COLOR_TABLE_WIDTH = 0x80D9,
-            POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2,
-            COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC,
-            COLOR_TABLE = 0x80D0,
-            PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
-            COLOR_TABLE_RED_SIZE_SGI = 0x80DA,
-            COLOR_TABLE_LUMINANCE_SIZE = 0x80DE,
-            POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1,
-            COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB,
-            COLOR_TABLE_RED_SIZE = 0x80DA,
-            COLOR_TABLE_INTENSITY_SIZE = 0x80DF,
-            COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD,
-        }
-
-        public enum SGIS_detail_texture : uint
-        {
-            DETAIL_TEXTURE_MODE_SGIS = 0x809B,
-            DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096,
-            DETAIL_TEXTURE_LEVEL_SGIS = 0x809A,
-            DETAIL_TEXTURE_2D_SGIS = 0x8095,
-            LINEAR_DETAIL_SGIS = 0x8097,
-            DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C,
-            LINEAR_DETAIL_ALPHA_SGIS = 0x8098,
-            LINEAR_DETAIL_COLOR_SGIS = 0x8099,
-        }
-
-        public enum HP_occlusion_test : uint
-        {
-            OCCLUSION_TEST_HP = 0x8165,
-            OCCLUSION_TEST_RESULT_HP = 0x8166,
-        }
-
-        public enum ATI_texture_float : uint
-        {
-            ALPHA_FLOAT32_ATI = 0x8816,
-            INTENSITY_FLOAT32_ATI = 0x8817,
-            LUMINANCE_FLOAT32_ATI = 0x8818,
-            LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F,
-            ALPHA_FLOAT16_ATI = 0x881C,
-            LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819,
-            RGBA_FLOAT16_ATI = 0x881A,
-            RGBA_FLOAT32_ATI = 0x8814,
-            LUMINANCE_FLOAT16_ATI = 0x881E,
-            RGB_FLOAT32_ATI = 0x8815,
-            INTENSITY_FLOAT16_ATI = 0x881D,
-            RGB_FLOAT16_ATI = 0x881B,
-        }
-
-        public enum SGIX_texture_multi_buffer : uint
-        {
-            TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E,
-        }
-
-        public enum _3DFX_tbuffer : uint
-        {
-        }
-
-        public enum EXT_vertex_shader : uint
-        {
-            OP_INDEX_EXT = 0x8782,
-            OP_MOV_EXT = 0x8799,
-            OP_MULTIPLY_MATRIX_EXT = 0x8798,
-            VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF,
-            VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4,
-            OUTPUT_FOG_EXT = 0x87BD,
-            Y_EXT = 0x87D6,
-            OP_ROUND_EXT = 0x8790,
-            OUTPUT_TEXTURE_COORD28_EXT = 0x87B9,
-            INVARIANT_EXT = 0x87C2,
-            MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6,
-            OP_POWER_EXT = 0x8793,
-            CURRENT_VERTEX_EXT = 0x87E2,
-            OUTPUT_TEXTURE_COORD1_EXT = 0x879E,
-            OUTPUT_TEXTURE_COORD29_EXT = 0x87BA,
-            LOCAL_EXT = 0x87C4,
-            OUTPUT_TEXTURE_COORD4_EXT = 0x87A1,
-            OUTPUT_TEXTURE_COORD20_EXT = 0x87B1,
-            VARIANT_ARRAY_POINTER_EXT = 0x87E9,
-            Z_EXT = 0x87D7,
-            VARIANT_ARRAY_STRIDE_EXT = 0x87E6,
-            VARIANT_VALUE_EXT = 0x87E4,
-            MVP_MATRIX_EXT = 0x87E3,
-            VERTEX_SHADER_BINDING_EXT = 0x8781,
-            OUTPUT_TEXTURE_COORD19_EXT = 0x87B0,
-            INVARIANT_VALUE_EXT = 0x87EA,
-            OUTPUT_TEXTURE_COORD21_EXT = 0x87B2,
-            MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8,
-            OUTPUT_TEXTURE_COORD3_EXT = 0x87A0,
-            OUTPUT_TEXTURE_COORD10_EXT = 0x87A7,
-            OP_MUL_EXT = 0x8786,
-            NEGATIVE_ONE_EXT = 0x87DF,
-            OP_CROSS_PRODUCT_EXT = 0x8797,
-            VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2,
-            OUTPUT_TEXTURE_COORD18_EXT = 0x87AF,
-            OP_NEGATE_EXT = 0x8783,
-            OUTPUT_TEXTURE_COORD6_EXT = 0x87A3,
-            VERTEX_SHADER_INVARIANTS_EXT = 0x87D1,
-            OUTPUT_TEXTURE_COORD11_EXT = 0x87A8,
-            W_EXT = 0x87D8,
-            OP_SET_LT_EXT = 0x878D,
-            ONE_EXT = 0x87DE,
-            VARIANT_ARRAY_EXT = 0x87E8,
-            OUTPUT_COLOR1_EXT = 0x879C,
-            OUTPUT_TEXTURE_COORD13_EXT = 0x87AA,
-            OUTPUT_TEXTURE_COORD24_EXT = 0x87B5,
-            X_EXT = 0x87D5,
-            ZERO_EXT = 0x87DD,
-            LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED,
-            SCALAR_EXT = 0x87BE,
-            OUTPUT_TEXTURE_COORD30_EXT = 0x87BB,
-            VARIANT_ARRAY_TYPE_EXT = 0x87E7,
-            VERTEX_SHADER_VARIANTS_EXT = 0x87D0,
-            OUTPUT_TEXTURE_COORD5_EXT = 0x87A2,
-            NEGATIVE_W_EXT = 0x87DC,
-            OUTPUT_TEXTURE_COORD25_EXT = 0x87B6,
-            MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD,
-            OP_FLOOR_EXT = 0x878F,
-            NEGATIVE_Y_EXT = 0x87DA,
-            MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7,
-            OUTPUT_TEXTURE_COORD8_EXT = 0x87A5,
-            OP_RECIP_EXT = 0x8794,
-            OUTPUT_TEXTURE_COORD31_EXT = 0x87BC,
-            OUTPUT_TEXTURE_COORD14_EXT = 0x87AB,
-            NEGATIVE_X_EXT = 0x87D9,
-            MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5,
-            VARIANT_DATATYPE_EXT = 0x87E5,
-            OUTPUT_VERTEX_EXT = 0x879A,
-            OP_ADD_EXT = 0x8787,
-            OUTPUT_TEXTURE_COORD0_EXT = 0x879D,
-            OUTPUT_TEXTURE_COORD15_EXT = 0x87AC,
-            OP_MADD_EXT = 0x8788,
-            OP_DOT3_EXT = 0x8784,
-            MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE,
-            OUTPUT_TEXTURE_COORD7_EXT = 0x87A4,
-            LOCAL_CONSTANT_EXT = 0x87C3,
-            VECTOR_EXT = 0x87BF,
-            VERTEX_SHADER_EXT = 0x8780,
-            NORMALIZED_RANGE_EXT = 0x87E0,
-            VARIANT_EXT = 0x87C1,
-            OUTPUT_TEXTURE_COORD26_EXT = 0x87B7,
-            OP_MAX_EXT = 0x878A,
-            OP_CLAMP_EXT = 0x878E,
-            INVARIANT_DATATYPE_EXT = 0x87EB,
-            MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9,
-            OUTPUT_TEXTURE_COORD22_EXT = 0x87B3,
-            OP_SET_GE_EXT = 0x878C,
-            OP_FRAC_EXT = 0x8789,
-            VERTEX_SHADER_LOCALS_EXT = 0x87D3,
-            MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA,
-            LOCAL_CONSTANT_VALUE_EXT = 0x87EC,
-            OUTPUT_TEXTURE_COORD27_EXT = 0x87B8,
-            NEGATIVE_Z_EXT = 0x87DB,
-            OP_RECIP_SQRT_EXT = 0x8795,
-            MATRIX_EXT = 0x87C0,
-            OP_EXP_BASE_2_EXT = 0x8791,
-            OUTPUT_TEXTURE_COORD16_EXT = 0x87AD,
-            OUTPUT_TEXTURE_COORD23_EXT = 0x87B4,
-            OUTPUT_COLOR0_EXT = 0x879B,
-            OP_MIN_EXT = 0x878B,
-            OP_DOT4_EXT = 0x8785,
-            OUTPUT_TEXTURE_COORD12_EXT = 0x87A9,
-            OP_SUB_EXT = 0x8796,
-            MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB,
-            MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC,
-            OUTPUT_TEXTURE_COORD2_EXT = 0x879F,
-            OUTPUT_TEXTURE_COORD17_EXT = 0x87AE,
-            OP_LOG_BASE_2_EXT = 0x8792,
-            OUTPUT_TEXTURE_COORD9_EXT = 0x87A6,
-            FULL_RANGE_EXT = 0x87E1,
-        }
-
-        public enum EXT_texture_sRGB : uint
-        {
-            COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F,
-            SRGB8_EXT = 0x8C41,
-            SLUMINANCE8_ALPHA8_EXT = 0x8C45,
-            COMPRESSED_SRGB_ALPHA_EXT = 0x8C49,
-            SLUMINANCE_EXT = 0x8C46,
-            COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C,
-            SLUMINANCE_ALPHA_EXT = 0x8C44,
-            COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D,
-            SRGB8_ALPHA8_EXT = 0x8C43,
-            SRGB_ALPHA_EXT = 0x8C42,
-            SRGB_EXT = 0x8C40,
-            COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E,
-            SLUMINANCE8_EXT = 0x8C47,
-            COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B,
-            COMPRESSED_SRGB_EXT = 0x8C48,
-            COMPRESSED_SLUMINANCE_EXT = 0x8C4A,
-        }
-
-        public enum ClipPlaneName : uint
-        {
-            CLIP_PLANE3 = 0x3003,
-            CLIP_PLANE2 = 0x3002,
-            CLIP_PLANE5 = 0x3005,
-            CLIP_PLANE1 = 0x3001,
-            CLIP_PLANE0 = 0x3000,
-            CLIP_PLANE4 = 0x3004,
-        }
-
-        public enum NormalPointerType : uint
-        {
-            DOUBLE = DataType.DOUBLE,
-            BYTE = DataType.BYTE,
-            SHORT = DataType.SHORT,
-            INT = DataType.INT,
-            FLOAT = DataType.FLOAT,
-        }
-
-        public enum ARB_texture_cube_map : uint
-        {
-            TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517,
-            TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516,
-            TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518,
-            TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515,
-            TEXTURE_CUBE_MAP_ARB = 0x8513,
-            TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A,
-            MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C,
-            REFLECTION_MAP_ARB = 0x8512,
-            TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514,
-            NORMAL_MAP_ARB = 0x8511,
-            PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B,
-            TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519,
-        }
-
-        public enum SGIX_impact_pixel_texture : uint
-        {
-            PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188,
-            PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185,
-            PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184,
-            PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186,
-            PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A,
-            PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187,
-            PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189,
-        }
-
-        public enum EXT_cmyka : uint
-        {
-            UNPACK_CMYK_HINT_EXT = 0x800F,
-            PACK_CMYK_HINT_EXT = 0x800E,
-            CMYKA_EXT = 0x800D,
-            CMYK_EXT = 0x800C,
-        }
-
-        public enum StencilFunction : uint
-        {
-            NEVER = AlphaFunction.NEVER,
-            GEQUAL = AlphaFunction.GEQUAL,
-            GREATER = AlphaFunction.GREATER,
-            ALWAYS = AlphaFunction.ALWAYS,
-            LEQUAL = AlphaFunction.LEQUAL,
-            NOTEQUAL = AlphaFunction.NOTEQUAL,
-            EQUAL = AlphaFunction.EQUAL,
-            LESS = AlphaFunction.LESS,
-        }
-
-        public enum SGIX_icc_texture : uint
-        {
-            RGBA_ICC_SGIX = 0x8461,
-            INTENSITY_ICC_SGIX = 0x8464,
-            ALPHA_ICC_SGIX = 0x8462,
-            LUMINANCE_ICC_SGIX = 0x8463,
-            LUMINANCE16_ICC_SGIX = 0x8469,
-            R5_G6_B5_ICC_SGIX = 0x8466,
-            ALPHA16_ICC_SGIX = 0x8468,
-            INTENSITY16_ICC_SGIX = 0x846A,
-            RGB_ICC_SGIX = 0x8460,
-            LUMINANCE_ALPHA_ICC_SGIX = 0x8465,
-            R5_G6_B5_A8_ICC_SGIX = 0x8467,
-            LUMINANCE16_ALPHA8_ICC_SGIX = 0x846B,
-        }
-
-        public enum VERSION_1_2 : uint
-        {
-            TEXTURE_BASE_LEVEL = 0x813C,
-            UNSIGNED_SHORT_5_6_5_REV = 0x8364,
-            PACK_IMAGE_HEIGHT = 0x806C,
-            MAX_ELEMENTS_INDICES = 0x80E9,
-            UNPACK_SKIP_IMAGES = 0x806D,
-            LIGHT_MODEL_COLOR_CONTROL = 0x81F8,
-            UNSIGNED_INT_8_8_8_8_REV = 0x8367,
-            SMOOTH_LINE_WIDTH_RANGE = 0x0B22,
-            TEXTURE_WRAP_R = 0x8072,
-            PACK_SKIP_IMAGES = 0x806B,
-            UNSIGNED_BYTE_2_3_3_REV = 0x8362,
-            UNSIGNED_SHORT_5_6_5 = 0x8363,
-            UNSIGNED_INT_8_8_8_8 = 0x8035,
-            PROXY_TEXTURE_3D = 0x8070,
-            SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13,
-            UNSIGNED_SHORT_5_5_5_1 = 0x8034,
-            TEXTURE_MAX_LOD = 0x813B,
-            UNSIGNED_BYTE_3_3_2 = 0x8032,
-            TEXTURE_MAX_LEVEL = 0x813D,
-            BGRA = 0x80E1,
-            SEPARATE_SPECULAR_COLOR = 0x81FA,
-            ALIASED_POINT_SIZE_RANGE = 0x846D,
-            SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23,
-            SINGLE_COLOR = 0x81F9,
-            RESCALE_NORMAL = 0x803A,
-            UNSIGNED_INT_10_10_10_2 = 0x8036,
-            ALIASED_LINE_WIDTH_RANGE = 0x846E,
-            UNPACK_IMAGE_HEIGHT = 0x806E,
-            UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
-            TEXTURE_MIN_LOD = 0x813A,
-            MAX_3D_TEXTURE_SIZE = 0x8073,
-            TEXTURE_3D = 0x806F,
-            SMOOTH_POINT_SIZE_RANGE = 0x0B12,
-            MAX_ELEMENTS_VERTICES = 0x80E8,
-            TEXTURE_DEPTH = 0x8071,
-            UNSIGNED_INT_2_10_10_10_REV = 0x8368,
-            TEXTURE_BINDING_3D = 0x806A,
-            UNSIGNED_SHORT_4_4_4_4 = 0x8033,
-            UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
-            BGR = 0x80E0,
-            CLAMP_TO_EDGE = 0x812F,
-        }
-
-        public enum NV_vertex_program1_1 : uint
-        {
-        }
-
-        public enum EXT_compiled_vertex_array : uint
-        {
-            ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9,
-            ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8,
-        }
-
-        public enum MESAX_texture_stack : uint
-        {
-            TEXTURE_1D_STACK_MESAX = 0x8759,
-            PROXY_TEXTURE_2D_STACK_MESAX = 0x875C,
-            TEXTURE_2D_STACK_MESAX = 0x875A,
-            TEXTURE_1D_STACK_BINDING_MESAX = 0x875D,
-            PROXY_TEXTURE_1D_STACK_MESAX = 0x875B,
-            TEXTURE_2D_STACK_BINDING_MESAX = 0x875E,
-        }
-
-        public enum EXT_timer_query : uint
-        {
-            TIME_ELAPSED_EXT = 0x88BF,
-        }
-
-    }
-    #endregion
-
-    public static partial class GL
-    {
         #region Function signatures
 
         public static class Delegates
@@ -5278,7 +91,7 @@ namespace OpenTK.OpenGL
             public delegate void Color4uiv_(IntPtr v);
             public delegate void Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
             public delegate void Color4usv_(IntPtr v);
-            public delegate void EdgeFlag(GLboolean flag);
+            public delegate void EdgeFlag(Enums.Boolean flag);
             public delegate void EdgeFlagv_(IntPtr flag);
             public delegate void End();
             public delegate void Indexd(GLdouble c);
@@ -5447,8 +260,8 @@ namespace OpenTK.OpenGL
             public delegate void ClearStencil(GLint s);
             public delegate void ClearDepth(GLclampd depth);
             public delegate void StencilMask(GLuint mask);
-            public delegate void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-            public delegate void DepthMask(GLboolean flag);
+            public delegate void ColorMask(Enums.Boolean red, Enums.Boolean green, Enums.Boolean blue, Enums.Boolean alpha);
+            public delegate void DepthMask(Enums.Boolean flag);
             public delegate void IndexMask(GLuint mask);
             public delegate void Accum(Enums.AccumOp op, GLfloat value);
             public delegate void Disable(Enums.EnableCap cap);
@@ -5598,14 +411,14 @@ namespace OpenTK.OpenGL
             public delegate void GetConvolutionParameteriv_(GLenum target, GLenum pname, IntPtr parameters);
             public delegate void GetSeparableFilter_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, IntPtr span);
             public delegate void SeparableFilter2D_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column);
-            public delegate void GetHistogram_(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
+            public delegate void GetHistogram_(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
             public delegate void GetHistogramParameterfv_(GLenum target, GLenum pname, IntPtr parameters);
             public delegate void GetHistogramParameteriv_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetMinmax_(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
+            public delegate void GetMinmax_(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
             public delegate void GetMinmaxParameterfv_(GLenum target, GLenum pname, IntPtr parameters);
             public delegate void GetMinmaxParameteriv_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void Histogram(GLenum target, GLsizei width, Enums.PixelInternalFormat internalformat, GLboolean sink);
-            public delegate void Minmax(GLenum target, Enums.PixelInternalFormat internalformat, GLboolean sink);
+            public delegate void Histogram(GLenum target, GLsizei width, Enums.PixelInternalFormat internalformat, Enums.Boolean sink);
+            public delegate void Minmax(GLenum target, Enums.PixelInternalFormat internalformat, Enums.Boolean sink);
             public delegate void ResetHistogram(GLenum target);
             public delegate void ResetMinmax(GLenum target);
             public delegate void TexImage3D_(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
@@ -5649,7 +462,7 @@ namespace OpenTK.OpenGL
             public delegate void LoadTransposeMatrixd_(IntPtr m);
             public delegate void MultTransposeMatrixf_(IntPtr m);
             public delegate void MultTransposeMatrixd_(IntPtr m);
-            public delegate void SampleCoverage(GLclampf value, GLboolean invert);
+            public delegate void SampleCoverage(GLclampf value, Enums.Boolean invert);
             public delegate void CompressedTexImage3D_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data);
             public delegate void CompressedTexImage2D_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data);
             public delegate void CompressedTexImage1D_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data);
@@ -5773,9 +586,9 @@ namespace OpenTK.OpenGL
             public delegate void Uniform2iv_(GLint location, GLsizei count, IntPtr value);
             public delegate void Uniform3iv_(GLint location, GLsizei count, IntPtr value);
             public delegate void Uniform4iv_(GLint location, GLsizei count, IntPtr value);
-            public delegate void UniformMatrix2fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix3fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix4fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public delegate void UniformMatrix2fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix3fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix4fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             public delegate void ValidateProgram(GLuint program);
             public delegate void VertexAttrib1d(GLuint index, GLdouble x);
             public delegate void VertexAttrib1dv_(GLuint index, IntPtr v);
@@ -5813,865 +626,13 @@ namespace OpenTK.OpenGL
             public delegate void VertexAttrib4ubv_(GLuint index, IntPtr v);
             public delegate void VertexAttrib4uiv_(GLuint index, IntPtr v);
             public delegate void VertexAttrib4usv_(GLuint index, IntPtr v);
-            public delegate void VertexAttribPointer_(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, IntPtr pointer);
-            public delegate void UniformMatrix2x3fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix3x2fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix2x4fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix4x2fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix3x4fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix4x3fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void ActiveTextureARB(GLenum texture);
-            public delegate void ClientActiveTextureARB(GLenum texture);
-            public delegate void MultiTexCoord1dARB(GLenum target, GLdouble s);
-            public delegate void MultiTexCoord1dvARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord1fARB(GLenum target, GLfloat s);
-            public delegate void MultiTexCoord1fvARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord1iARB(GLenum target, GLint s);
-            public delegate void MultiTexCoord1ivARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord1sARB(GLenum target, GLshort s);
-            public delegate void MultiTexCoord1svARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t);
-            public delegate void MultiTexCoord2dvARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t);
-            public delegate void MultiTexCoord2fvARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord2iARB(GLenum target, GLint s, GLint t);
-            public delegate void MultiTexCoord2ivARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord2sARB(GLenum target, GLshort s, GLshort t);
-            public delegate void MultiTexCoord2svARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-            public delegate void MultiTexCoord3dvARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-            public delegate void MultiTexCoord3fvARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r);
-            public delegate void MultiTexCoord3ivARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r);
-            public delegate void MultiTexCoord3svARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-            public delegate void MultiTexCoord4dvARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-            public delegate void MultiTexCoord4fvARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q);
-            public delegate void MultiTexCoord4ivARB_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-            public delegate void MultiTexCoord4svARB_(GLenum target, IntPtr v);
-            public delegate void LoadTransposeMatrixfARB_(IntPtr m);
-            public delegate void LoadTransposeMatrixdARB_(IntPtr m);
-            public delegate void MultTransposeMatrixfARB_(IntPtr m);
-            public delegate void MultTransposeMatrixdARB_(IntPtr m);
-            public delegate void SampleCoverageARB(GLclampf value, GLboolean invert);
-            public delegate void CompressedTexImage3DARB_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data);
-            public delegate void CompressedTexImage2DARB_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data);
-            public delegate void CompressedTexImage1DARB_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data);
-            public delegate void CompressedTexSubImage3DARB_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data);
-            public delegate void CompressedTexSubImage2DARB_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data);
-            public delegate void CompressedTexSubImage1DARB_(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data);
-            public delegate void GetCompressedTexImageARB_(Enums.TextureTarget target, GLint level, IntPtr img);
-            public delegate void PointParameterfARB(GLenum pname, GLfloat param);
-            public delegate void PointParameterfvARB_(GLenum pname, IntPtr parameters);
-            public delegate void WeightbvARB_(GLint size, IntPtr weights);
-            public delegate void WeightsvARB_(GLint size, IntPtr weights);
-            public delegate void WeightivARB_(GLint size, IntPtr weights);
-            public delegate void WeightfvARB_(GLint size, IntPtr weights);
-            public delegate void WeightdvARB_(GLint size, IntPtr weights);
-            public delegate void WeightubvARB_(GLint size, IntPtr weights);
-            public delegate void WeightusvARB_(GLint size, IntPtr weights);
-            public delegate void WeightuivARB_(GLint size, IntPtr weights);
-            public delegate void WeightPointerARB_(GLint size, GLenum type, GLsizei stride, IntPtr pointer);
-            public delegate void VertexBlendARB(GLint count);
-            public delegate void CurrentPaletteMatrixARB(GLint index);
-            public delegate void MatrixIndexubvARB_(GLint size, IntPtr indices);
-            public delegate void MatrixIndexusvARB_(GLint size, IntPtr indices);
-            public delegate void MatrixIndexuivARB_(GLint size, IntPtr indices);
-            public delegate void MatrixIndexPointerARB_(GLint size, GLenum type, GLsizei stride, IntPtr pointer);
-            public delegate void WindowPos2dARB(GLdouble x, GLdouble y);
-            public delegate void WindowPos2dvARB_(IntPtr v);
-            public delegate void WindowPos2fARB(GLfloat x, GLfloat y);
-            public delegate void WindowPos2fvARB_(IntPtr v);
-            public delegate void WindowPos2iARB(GLint x, GLint y);
-            public delegate void WindowPos2ivARB_(IntPtr v);
-            public delegate void WindowPos2sARB(GLshort x, GLshort y);
-            public delegate void WindowPos2svARB_(IntPtr v);
-            public delegate void WindowPos3dARB(GLdouble x, GLdouble y, GLdouble z);
-            public delegate void WindowPos3dvARB_(IntPtr v);
-            public delegate void WindowPos3fARB(GLfloat x, GLfloat y, GLfloat z);
-            public delegate void WindowPos3fvARB_(IntPtr v);
-            public delegate void WindowPos3iARB(GLint x, GLint y, GLint z);
-            public delegate void WindowPos3ivARB_(IntPtr v);
-            public delegate void WindowPos3sARB(GLshort x, GLshort y, GLshort z);
-            public delegate void WindowPos3svARB_(IntPtr v);
-            public delegate void VertexAttrib1dARB(GLuint index, GLdouble x);
-            public delegate void VertexAttrib1dvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib1fARB(GLuint index, GLfloat x);
-            public delegate void VertexAttrib1fvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib1sARB(GLuint index, GLshort x);
-            public delegate void VertexAttrib1svARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y);
-            public delegate void VertexAttrib2dvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y);
-            public delegate void VertexAttrib2fvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib2sARB(GLuint index, GLshort x, GLshort y);
-            public delegate void VertexAttrib2svARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-            public delegate void VertexAttrib3dvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void VertexAttrib3fvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z);
-            public delegate void VertexAttrib3svARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4NbvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4NivARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4NsvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-            public delegate void VertexAttrib4NubvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4NuivARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4NusvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4bvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-            public delegate void VertexAttrib4dvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void VertexAttrib4fvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4ivARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-            public delegate void VertexAttrib4svARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4ubvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4uivARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4usvARB_(GLuint index, IntPtr v);
-            public delegate void VertexAttribPointerARB_(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, IntPtr pointer);
-            public delegate void EnableVertexAttribArrayARB(GLuint index);
-            public delegate void DisableVertexAttribArrayARB(GLuint index);
-            public delegate void ProgramStringARB_(GLenum target, GLenum format, GLsizei len, IntPtr @string);
-            public delegate void BindProgramARB(GLenum target, GLuint program);
-            public delegate void DeleteProgramsARB_(GLsizei n, IntPtr programs);
-            public delegate void GenProgramsARB_(GLsizei n, IntPtr programs);
-            public delegate void ProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-            public delegate void ProgramEnvParameter4dvARB_(GLenum target, GLuint index, IntPtr parameters);
-            public delegate void ProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void ProgramEnvParameter4fvARB_(GLenum target, GLuint index, IntPtr parameters);
-            public delegate void ProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-            public delegate void ProgramLocalParameter4dvARB_(GLenum target, GLuint index, IntPtr parameters);
-            public delegate void ProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void ProgramLocalParameter4fvARB_(GLenum target, GLuint index, IntPtr parameters);
-            public delegate void GetProgramEnvParameterdvARB_(GLenum target, GLuint index, IntPtr parameters);
-            public delegate void GetProgramEnvParameterfvARB_(GLenum target, GLuint index, IntPtr parameters);
-            public delegate void GetProgramLocalParameterdvARB_(GLenum target, GLuint index, IntPtr parameters);
-            public delegate void GetProgramLocalParameterfvARB_(GLenum target, GLuint index, IntPtr parameters);
-            public delegate void GetProgramivARB_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetProgramStringARB_(GLenum target, GLenum pname, IntPtr @string);
-            public delegate void GetVertexAttribdvARB_(GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetVertexAttribfvARB_(GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetVertexAttribivARB_(GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetVertexAttribPointervARB_(GLuint index, GLenum pname, IntPtr pointer);
-            public delegate GLboolean IsProgramARB(GLuint program);
-            public delegate void BindBufferARB(GLenum target, GLuint buffer);
-            public delegate void DeleteBuffersARB_(GLsizei n, IntPtr buffers);
-            public delegate void GenBuffersARB_(GLsizei n, IntPtr buffers);
-            public delegate GLboolean IsBufferARB(GLuint buffer);
-            public delegate void BufferDataARB_(GLenum target, GLsizeiptrARB size, IntPtr data, GLenum usage);
-            public delegate void BufferSubDataARB_(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data);
-            public delegate void GetBufferSubDataARB_(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data);
-            public delegate IntPtr MapBufferARB(GLenum target, GLenum access);
-            public delegate GLboolean UnmapBufferARB(GLenum target);
-            public delegate void GetBufferParameterivARB_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetBufferPointervARB_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GenQueriesARB_(GLsizei n, IntPtr ids);
-            public delegate void DeleteQueriesARB_(GLsizei n, IntPtr ids);
-            public delegate GLboolean IsQueryARB(GLuint id);
-            public delegate void BeginQueryARB(Enums.ARB_occlusion_query target, GLuint id);
-            public delegate void EndQueryARB(Enums.ARB_occlusion_query target);
-            public delegate void GetQueryivARB_(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, IntPtr parameters);
-            public delegate void GetQueryObjectivARB_(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters);
-            public delegate void GetQueryObjectuivARB_(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters);
-            public delegate void DeleteObjectARB(GLhandleARB obj);
-            public delegate GLhandleARB GetHandleARB(Enums.ARB_shader_objects pname);
-            public delegate void DetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj);
-            public delegate GLhandleARB CreateShaderObjectARB(Enums.ARB_shader_objects shaderType);
-            public delegate void ShaderSourceARB_(GLhandleARB shaderObj, GLsizei count, string @string, IntPtr length);
-            public delegate void CompileShaderARB(GLhandleARB shaderObj);
-            public delegate GLhandleARB CreateProgramObjectARB();
-            public delegate void AttachObjectARB(GLhandleARB containerObj, GLhandleARB obj);
-            public delegate void LinkProgramARB(GLhandleARB programObj);
-            public delegate void UseProgramObjectARB(GLhandleARB programObj);
-            public delegate void ValidateProgramARB(GLhandleARB programObj);
-            public delegate void Uniform1fARB(GLint location, GLfloat v0);
-            public delegate void Uniform2fARB(GLint location, GLfloat v0, GLfloat v1);
-            public delegate void Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-            public delegate void Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-            public delegate void Uniform1iARB(GLint location, GLint v0);
-            public delegate void Uniform2iARB(GLint location, GLint v0, GLint v1);
-            public delegate void Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2);
-            public delegate void Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-            public delegate void Uniform1fvARB_(GLint location, GLsizei count, IntPtr value);
-            public delegate void Uniform2fvARB_(GLint location, GLsizei count, IntPtr value);
-            public delegate void Uniform3fvARB_(GLint location, GLsizei count, IntPtr value);
-            public delegate void Uniform4fvARB_(GLint location, GLsizei count, IntPtr value);
-            public delegate void Uniform1ivARB_(GLint location, GLsizei count, IntPtr value);
-            public delegate void Uniform2ivARB_(GLint location, GLsizei count, IntPtr value);
-            public delegate void Uniform3ivARB_(GLint location, GLsizei count, IntPtr value);
-            public delegate void Uniform4ivARB_(GLint location, GLsizei count, IntPtr value);
-            public delegate void UniformMatrix2fvARB_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix3fvARB_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void UniformMatrix4fvARB_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
-            public delegate void GetObjectParameterfvARB_(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters);
-            public delegate void GetObjectParameterivARB_(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters);
-            public delegate void GetInfoLogARB_(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder infoLog);
-            public delegate void GetAttachedObjectsARB_(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, IntPtr obj);
-            public delegate GLint GetUniformLocationARB(GLhandleARB programObj, string name);
-            public delegate void GetActiveUniformARB_(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name);
-            public delegate void GetUniformfvARB_(GLhandleARB programObj, GLint location, IntPtr parameters);
-            public delegate void GetUniformivARB_(GLhandleARB programObj, GLint location, IntPtr parameters);
-            public delegate void GetShaderSourceARB_(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder source);
-            public delegate void BindAttribLocationARB(GLhandleARB programObj, GLuint index, string name);
-            public delegate void GetActiveAttribARB_(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name);
-            public delegate GLint GetAttribLocationARB(GLhandleARB programObj, string name);
-            public delegate void DrawBuffersARB_(GLsizei n, IntPtr bufs);
-            public delegate void ClampColorARB(GLenum target, GLenum clamp);
-            public delegate void BlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-            public delegate void PolygonOffsetEXT(GLfloat factor, GLfloat bias);
-            public delegate void TexImage3DEXT_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
-            public delegate void TexSubImage3DEXT_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
-            public delegate void GetTexFilterFuncSGIS_(Enums.TextureTarget target, GLenum filter, IntPtr weights);
-            public delegate void TexFilterFuncSGIS_(Enums.TextureTarget target, GLenum filter, GLsizei n, IntPtr weights);
-            public delegate void TexSubImage1DEXT_(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
-            public delegate void TexSubImage2DEXT_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
-            public delegate void CopyTexImage1DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border);
-            public delegate void CopyTexImage2DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-            public delegate void CopyTexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-            public delegate void CopyTexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-            public delegate void CopyTexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-            public delegate void GetHistogramEXT_(Enums.HistogramTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
-            public delegate void GetHistogramParameterfvEXT_(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters);
-            public delegate void GetHistogramParameterivEXT_(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters);
-            public delegate void GetMinmaxEXT_(Enums.MinmaxTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
-            public delegate void GetMinmaxParameterfvEXT_(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters);
-            public delegate void GetMinmaxParameterivEXT_(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters);
-            public delegate void HistogramEXT(Enums.HistogramTargetEXT target, GLsizei width, Enums.PixelInternalFormat internalformat, GLboolean sink);
-            public delegate void MinmaxEXT(Enums.MinmaxTargetEXT target, Enums.PixelInternalFormat internalformat, GLboolean sink);
-            public delegate void ResetHistogramEXT(Enums.HistogramTargetEXT target);
-            public delegate void ResetMinmaxEXT(Enums.MinmaxTargetEXT target);
-            public delegate void ConvolutionFilter1DEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image);
-            public delegate void ConvolutionFilter2DEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image);
-            public delegate void ConvolutionParameterfEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat parameters);
-            public delegate void ConvolutionParameterfvEXT_(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters);
-            public delegate void ConvolutionParameteriEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint parameters);
-            public delegate void ConvolutionParameterivEXT_(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters);
-            public delegate void CopyConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
-            public delegate void CopyConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-            public delegate void GetConvolutionFilterEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr image);
-            public delegate void GetConvolutionParameterfvEXT_(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters);
-            public delegate void GetConvolutionParameterivEXT_(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters);
-            public delegate void GetSeparableFilterEXT_(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, IntPtr span);
-            public delegate void SeparableFilter2DEXT_(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column);
-            public delegate void ColorTableSGI_(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table);
-            public delegate void ColorTableParameterfvSGI_(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters);
-            public delegate void ColorTableParameterivSGI_(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters);
-            public delegate void CopyColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
-            public delegate void GetColorTableSGI_(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, IntPtr table);
-            public delegate void GetColorTableParameterfvSGI_(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters);
-            public delegate void GetColorTableParameterivSGI_(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters);
-            public delegate void PixelTexGenSGIX(GLenum mode);
-            public delegate void PixelTexGenParameteriSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint param);
-            public delegate void PixelTexGenParameterivSGIS_(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters);
-            public delegate void PixelTexGenParameterfSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat param);
-            public delegate void PixelTexGenParameterfvSGIS_(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters);
-            public delegate void GetPixelTexGenParameterivSGIS_(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters);
-            public delegate void GetPixelTexGenParameterfvSGIS_(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters);
-            public delegate void TexImage4DSGIS_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
-            public delegate void TexSubImage4DSGIS_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
-            public delegate GLboolean AreTexturesResidentEXT_(GLsizei n, IntPtr textures, IntPtr residences);
-            public delegate void BindTextureEXT(Enums.TextureTarget target, GLuint texture);
-            public delegate void DeleteTexturesEXT_(GLsizei n, IntPtr textures);
-            public delegate void GenTexturesEXT_(GLsizei n, IntPtr textures);
-            public delegate GLboolean IsTextureEXT(GLuint texture);
-            public delegate void PrioritizeTexturesEXT_(GLsizei n, IntPtr textures, IntPtr priorities);
-            public delegate void DetailTexFuncSGIS_(Enums.TextureTarget target, GLsizei n, IntPtr points);
-            public delegate void GetDetailTexFuncSGIS_(Enums.TextureTarget target, IntPtr points);
-            public delegate void SharpenTexFuncSGIS_(Enums.TextureTarget target, GLsizei n, IntPtr points);
-            public delegate void GetSharpenTexFuncSGIS_(Enums.TextureTarget target, IntPtr points);
-            public delegate void SampleMaskSGIS(GLclampf value, GLboolean invert);
-            public delegate void SamplePatternSGIS(Enums.SamplePatternSGIS pattern);
-            public delegate void ArrayElementEXT(GLint i);
-            public delegate void ColorPointerEXT_(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
-            public delegate void DrawArraysEXT(Enums.BeginMode mode, GLint first, GLsizei count);
-            public delegate void EdgeFlagPointerEXT_(GLsizei stride, GLsizei count, IntPtr pointer);
-            public delegate void GetPointervEXT_(Enums.GetPointervPName pname, IntPtr parameters);
-            public delegate void IndexPointerEXT_(Enums.IndexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
-            public delegate void NormalPointerEXT_(Enums.NormalPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
-            public delegate void TexCoordPointerEXT_(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
-            public delegate void VertexPointerEXT_(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
-            public delegate void BlendEquationEXT(Enums.BlendEquationModeEXT mode);
-            public delegate void SpriteParameterfSGIX(GLenum pname, GLfloat param);
-            public delegate void SpriteParameterfvSGIX_(GLenum pname, IntPtr parameters);
-            public delegate void SpriteParameteriSGIX(GLenum pname, GLint param);
-            public delegate void SpriteParameterivSGIX_(GLenum pname, IntPtr parameters);
-            public delegate void PointParameterfEXT(GLenum pname, GLfloat param);
-            public delegate void PointParameterfvEXT_(GLenum pname, IntPtr parameters);
-            public delegate void PointParameterfSGIS(GLenum pname, GLfloat param);
-            public delegate void PointParameterfvSGIS_(GLenum pname, IntPtr parameters);
-            public delegate GLint GetInstrumentsSGIX();
-            public delegate void InstrumentsBufferSGIX_(GLsizei size, IntPtr buffer);
-            public delegate GLint PollInstrumentsSGIX_(IntPtr marker_p);
-            public delegate void ReadInstrumentsSGIX(GLint marker);
-            public delegate void StartInstrumentsSGIX();
-            public delegate void StopInstrumentsSGIX(GLint marker);
-            public delegate void FrameZoomSGIX(GLint factor);
-            public delegate void TagSampleBufferSGIX();
-            public delegate void DeformationMap3dSGIX_(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, IntPtr points);
-            public delegate void DeformationMap3fSGIX_(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, IntPtr points);
-            public delegate void DeformSGIX(Enums.FfdMaskSGIX mask);
-            public delegate void LoadIdentityDeformationMapSGIX(Enums.FfdMaskSGIX mask);
-            public delegate void ReferencePlaneSGIX_(IntPtr equation);
-            public delegate void FlushRasterSGIX();
-            public delegate void FogFuncSGIS_(GLsizei n, IntPtr points);
-            public delegate void GetFogFuncSGIS_(IntPtr points);
-            public delegate void ImageTransformParameteriHP(GLenum target, GLenum pname, GLint param);
-            public delegate void ImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param);
-            public delegate void ImageTransformParameterivHP_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void ImageTransformParameterfvHP_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetImageTransformParameterivHP_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetImageTransformParameterfvHP_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void ColorSubTableEXT_(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data);
-            public delegate void CopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-            public delegate void HintPGI(GLenum target, GLint mode);
-            public delegate void ColorTableEXT_(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table);
-            public delegate void GetColorTableEXT_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, IntPtr data);
-            public delegate void GetColorTableParameterivEXT_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetColorTableParameterfvEXT_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetListParameterfvSGIX_(GLuint list, Enums.ListParameterName pname, IntPtr parameters);
-            public delegate void GetListParameterivSGIX_(GLuint list, Enums.ListParameterName pname, IntPtr parameters);
-            public delegate void ListParameterfSGIX(GLuint list, Enums.ListParameterName pname, GLfloat param);
-            public delegate void ListParameterfvSGIX_(GLuint list, Enums.ListParameterName pname, IntPtr parameters);
-            public delegate void ListParameteriSGIX(GLuint list, Enums.ListParameterName pname, GLint param);
-            public delegate void ListParameterivSGIX_(GLuint list, Enums.ListParameterName pname, IntPtr parameters);
-            public delegate void IndexMaterialEXT(Enums.MaterialFace face, GLenum mode);
-            public delegate void IndexFuncEXT(GLenum func, GLclampf reference);
-            public delegate void LockArraysEXT(GLint first, GLsizei count);
-            public delegate void UnlockArraysEXT();
-            public delegate void CullParameterdvEXT_(GLenum pname, IntPtr parameters);
-            public delegate void CullParameterfvEXT_(GLenum pname, IntPtr parameters);
-            public delegate void FragmentColorMaterialSGIX(Enums.MaterialFace face, Enums.MaterialParameter mode);
-            public delegate void FragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param);
-            public delegate void FragmentLightfvSGIX_(GLenum light, GLenum pname, IntPtr parameters);
-            public delegate void FragmentLightiSGIX(GLenum light, GLenum pname, GLint param);
-            public delegate void FragmentLightivSGIX_(GLenum light, GLenum pname, IntPtr parameters);
-            public delegate void FragmentLightModelfSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat param);
-            public delegate void FragmentLightModelfvSGIX_(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters);
-            public delegate void FragmentLightModeliSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint param);
-            public delegate void FragmentLightModelivSGIX_(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters);
-            public delegate void FragmentMaterialfSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param);
-            public delegate void FragmentMaterialfvSGIX_(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters);
-            public delegate void FragmentMaterialiSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param);
-            public delegate void FragmentMaterialivSGIX_(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters);
-            public delegate void GetFragmentLightfvSGIX_(GLenum light, GLenum pname, IntPtr parameters);
-            public delegate void GetFragmentLightivSGIX_(GLenum light, GLenum pname, IntPtr parameters);
-            public delegate void GetFragmentMaterialfvSGIX_(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters);
-            public delegate void GetFragmentMaterialivSGIX_(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters);
-            public delegate void LightEnviSGIX(Enums.LightEnvParameterSGIX pname, GLint param);
-            public delegate void DrawRangeElementsEXT_(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices);
-            public delegate void ApplyTextureEXT(GLenum mode);
-            public delegate void TextureLightEXT(GLenum pname);
-            public delegate void TextureMaterialEXT(Enums.MaterialFace face, Enums.MaterialParameter mode);
-            public delegate void AsyncMarkerSGIX(GLuint marker);
-            public delegate GLint FinishAsyncSGIX_(IntPtr markerp);
-            public delegate GLint PollAsyncSGIX_(IntPtr markerp);
-            public delegate GLuint GenAsyncMarkersSGIX(GLsizei range);
-            public delegate void DeleteAsyncMarkersSGIX(GLuint marker, GLsizei range);
-            public delegate GLboolean IsAsyncMarkerSGIX(GLuint marker);
-            public delegate void VertexPointervINTEL_(GLint size, Enums.VertexPointerType type, IntPtr pointer);
-            public delegate void NormalPointervINTEL_(Enums.NormalPointerType type, IntPtr pointer);
-            public delegate void ColorPointervINTEL_(GLint size, Enums.VertexPointerType type, IntPtr pointer);
-            public delegate void TexCoordPointervINTEL_(GLint size, Enums.VertexPointerType type, IntPtr pointer);
-            public delegate void PixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param);
-            public delegate void PixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param);
-            public delegate void PixelTransformParameterivEXT_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void PixelTransformParameterfvEXT_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void SecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue);
-            public delegate void SecondaryColor3bvEXT_(IntPtr v);
-            public delegate void SecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue);
-            public delegate void SecondaryColor3dvEXT_(IntPtr v);
-            public delegate void SecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue);
-            public delegate void SecondaryColor3fvEXT_(IntPtr v);
-            public delegate void SecondaryColor3iEXT(GLint red, GLint green, GLint blue);
-            public delegate void SecondaryColor3ivEXT_(IntPtr v);
-            public delegate void SecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue);
-            public delegate void SecondaryColor3svEXT_(IntPtr v);
-            public delegate void SecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue);
-            public delegate void SecondaryColor3ubvEXT_(IntPtr v);
-            public delegate void SecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue);
-            public delegate void SecondaryColor3uivEXT_(IntPtr v);
-            public delegate void SecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue);
-            public delegate void SecondaryColor3usvEXT_(IntPtr v);
-            public delegate void SecondaryColorPointerEXT_(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer);
-            public delegate void TextureNormalEXT(GLenum mode);
-            public delegate void MultiDrawArraysEXT_(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount);
-            public delegate void MultiDrawElementsEXT_(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount);
-            public delegate void FogCoordfEXT(GLfloat coord);
-            public delegate void FogCoordfvEXT_(IntPtr coord);
-            public delegate void FogCoorddEXT(GLdouble coord);
-            public delegate void FogCoorddvEXT_(IntPtr coord);
-            public delegate void FogCoordPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer);
-            public delegate void Tangent3bEXT(GLbyte tx, GLbyte ty, GLbyte tz);
-            public delegate void Tangent3bvEXT_(IntPtr v);
-            public delegate void Tangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz);
-            public delegate void Tangent3dvEXT_(IntPtr v);
-            public delegate void Tangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz);
-            public delegate void Tangent3fvEXT_(IntPtr v);
-            public delegate void Tangent3iEXT(GLint tx, GLint ty, GLint tz);
-            public delegate void Tangent3ivEXT_(IntPtr v);
-            public delegate void Tangent3sEXT(GLshort tx, GLshort ty, GLshort tz);
-            public delegate void Tangent3svEXT_(IntPtr v);
-            public delegate void Binormal3bEXT(GLbyte bx, GLbyte by, GLbyte bz);
-            public delegate void Binormal3bvEXT_(IntPtr v);
-            public delegate void Binormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz);
-            public delegate void Binormal3dvEXT_(IntPtr v);
-            public delegate void Binormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz);
-            public delegate void Binormal3fvEXT_(IntPtr v);
-            public delegate void Binormal3iEXT(GLint bx, GLint by, GLint bz);
-            public delegate void Binormal3ivEXT_(IntPtr v);
-            public delegate void Binormal3sEXT(GLshort bx, GLshort by, GLshort bz);
-            public delegate void Binormal3svEXT_(IntPtr v);
-            public delegate void TangentPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer);
-            public delegate void BinormalPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer);
-            public delegate void FinishTextureSUNX();
-            public delegate void GlobalAlphaFactorbSUN(GLbyte factor);
-            public delegate void GlobalAlphaFactorsSUN(GLshort factor);
-            public delegate void GlobalAlphaFactoriSUN(GLint factor);
-            public delegate void GlobalAlphaFactorfSUN(GLfloat factor);
-            public delegate void GlobalAlphaFactordSUN(GLdouble factor);
-            public delegate void GlobalAlphaFactorubSUN(GLubyte factor);
-            public delegate void GlobalAlphaFactorusSUN(GLushort factor);
-            public delegate void GlobalAlphaFactoruiSUN(GLuint factor);
-            public delegate void ReplacementCodeuiSUN(GLuint code);
-            public delegate void ReplacementCodeusSUN(GLushort code);
-            public delegate void ReplacementCodeubSUN(GLubyte code);
-            public delegate void ReplacementCodeuivSUN_(IntPtr code);
-            public delegate void ReplacementCodeusvSUN_(IntPtr code);
-            public delegate void ReplacementCodeubvSUN_(IntPtr code);
-            public delegate void ReplacementCodePointerSUN_(GLenum type, GLsizei stride, IntPtr pointer);
-            public delegate void Color4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
-            public delegate void Color4ubVertex2fvSUN_(IntPtr c, IntPtr v);
-            public delegate void Color4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void Color4ubVertex3fvSUN_(IntPtr c, IntPtr v);
-            public delegate void Color3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void Color3fVertex3fvSUN_(IntPtr c, IntPtr v);
-            public delegate void Normal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void Normal3fVertex3fvSUN_(IntPtr n, IntPtr v);
-            public delegate void Color4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void Color4fNormal3fVertex3fvSUN_(IntPtr c, IntPtr n, IntPtr v);
-            public delegate void TexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void TexCoord2fVertex3fvSUN_(IntPtr tc, IntPtr v);
-            public delegate void TexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void TexCoord4fVertex4fvSUN_(IntPtr tc, IntPtr v);
-            public delegate void TexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void TexCoord2fColor4ubVertex3fvSUN_(IntPtr tc, IntPtr c, IntPtr v);
-            public delegate void TexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void TexCoord2fColor3fVertex3fvSUN_(IntPtr tc, IntPtr c, IntPtr v);
-            public delegate void TexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void TexCoord2fNormal3fVertex3fvSUN_(IntPtr tc, IntPtr n, IntPtr v);
-            public delegate void TexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void TexCoord2fColor4fNormal3fVertex3fvSUN_(IntPtr tc, IntPtr c, IntPtr n, IntPtr v);
-            public delegate void TexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void TexCoord4fColor4fNormal3fVertex4fvSUN_(IntPtr tc, IntPtr c, IntPtr n, IntPtr v);
-            public delegate void ReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void ReplacementCodeuiVertex3fvSUN_(IntPtr rc, IntPtr v);
-            public delegate void ReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void ReplacementCodeuiColor4ubVertex3fvSUN_(IntPtr rc, IntPtr c, IntPtr v);
-            public delegate void ReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void ReplacementCodeuiColor3fVertex3fvSUN_(IntPtr rc, IntPtr c, IntPtr v);
-            public delegate void ReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void ReplacementCodeuiNormal3fVertex3fvSUN_(IntPtr rc, IntPtr n, IntPtr v);
-            public delegate void ReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(IntPtr rc, IntPtr c, IntPtr n, IntPtr v);
-            public delegate void ReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void ReplacementCodeuiTexCoord2fVertex3fvSUN_(IntPtr rc, IntPtr tc, IntPtr v);
-            public delegate void ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(IntPtr rc, IntPtr tc, IntPtr n, IntPtr v);
-            public delegate void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v);
-            public delegate void BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-            public delegate void BlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
-            public delegate void VertexWeightfEXT(GLfloat weight);
-            public delegate void VertexWeightfvEXT_(IntPtr weight);
-            public delegate void VertexWeightPointerEXT_(GLsizei size, GLenum type, GLsizei stride, IntPtr pointer);
-            public delegate void FlushVertexArrayRangeNV();
-            public delegate void VertexArrayRangeNV_(GLsizei length, IntPtr pointer);
-            public delegate void CombinerParameterfvNV_(GLenum pname, IntPtr parameters);
-            public delegate void CombinerParameterfNV(GLenum pname, GLfloat param);
-            public delegate void CombinerParameterivNV_(GLenum pname, IntPtr parameters);
-            public delegate void CombinerParameteriNV(GLenum pname, GLint param);
-            public delegate void CombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
-            public delegate void CombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum);
-            public delegate void FinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
-            public delegate void GetCombinerInputParameterfvNV_(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters);
-            public delegate void GetCombinerInputParameterivNV_(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters);
-            public delegate void GetCombinerOutputParameterfvNV_(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters);
-            public delegate void GetCombinerOutputParameterivNV_(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters);
-            public delegate void GetFinalCombinerInputParameterfvNV_(GLenum variable, GLenum pname, IntPtr parameters);
-            public delegate void GetFinalCombinerInputParameterivNV_(GLenum variable, GLenum pname, IntPtr parameters);
-            public delegate void ResizeBuffersMESA();
-            public delegate void WindowPos2dMESA(GLdouble x, GLdouble y);
-            public delegate void WindowPos2dvMESA_(IntPtr v);
-            public delegate void WindowPos2fMESA(GLfloat x, GLfloat y);
-            public delegate void WindowPos2fvMESA_(IntPtr v);
-            public delegate void WindowPos2iMESA(GLint x, GLint y);
-            public delegate void WindowPos2ivMESA_(IntPtr v);
-            public delegate void WindowPos2sMESA(GLshort x, GLshort y);
-            public delegate void WindowPos2svMESA_(IntPtr v);
-            public delegate void WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z);
-            public delegate void WindowPos3dvMESA_(IntPtr v);
-            public delegate void WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z);
-            public delegate void WindowPos3fvMESA_(IntPtr v);
-            public delegate void WindowPos3iMESA(GLint x, GLint y, GLint z);
-            public delegate void WindowPos3ivMESA_(IntPtr v);
-            public delegate void WindowPos3sMESA(GLshort x, GLshort y, GLshort z);
-            public delegate void WindowPos3svMESA_(IntPtr v);
-            public delegate void WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-            public delegate void WindowPos4dvMESA_(IntPtr v);
-            public delegate void WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void WindowPos4fvMESA_(IntPtr v);
-            public delegate void WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w);
-            public delegate void WindowPos4ivMESA_(IntPtr v);
-            public delegate void WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w);
-            public delegate void WindowPos4svMESA_(IntPtr v);
-            public delegate void MultiModeDrawArraysIBM_(IntPtr mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride);
-            public delegate void MultiModeDrawElementsIBM_(IntPtr mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride);
-            public delegate void ColorPointerListIBM_(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
-            public delegate void SecondaryColorPointerListIBM_(GLint size, GLenum type, GLint stride, IntPtr pointer, GLint ptrstride);
-            public delegate void EdgeFlagPointerListIBM_(GLint stride, IntPtr pointer, GLint ptrstride);
-            public delegate void FogCoordPointerListIBM_(GLenum type, GLint stride, IntPtr pointer, GLint ptrstride);
-            public delegate void IndexPointerListIBM_(Enums.IndexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
-            public delegate void NormalPointerListIBM_(Enums.NormalPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
-            public delegate void TexCoordPointerListIBM_(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
-            public delegate void VertexPointerListIBM_(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
-            public delegate void TbufferMask3DFX(GLuint mask);
-            public delegate void SampleMaskEXT(GLclampf value, GLboolean invert);
-            public delegate void SamplePatternEXT(GLenum pattern);
-            public delegate void TextureColorMaskSGIS(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-            public delegate void IglooInterfaceSGIX_(GLenum pname, IntPtr parameters);
-            public delegate void DeleteFencesNV_(GLsizei n, IntPtr fences);
-            public delegate void GenFencesNV_(GLsizei n, IntPtr fences);
-            public delegate GLboolean IsFenceNV(GLuint fence);
-            public delegate GLboolean TestFenceNV(GLuint fence);
-            public delegate void GetFenceivNV_(GLuint fence, GLenum pname, IntPtr parameters);
-            public delegate void FinishFenceNV(GLuint fence);
-            public delegate void SetFenceNV(GLuint fence, GLenum condition);
-            public delegate void MapControlPointsNV_(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, IntPtr points);
-            public delegate void MapParameterivNV_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void MapParameterfvNV_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetMapControlPointsNV_(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, IntPtr points);
-            public delegate void GetMapParameterivNV_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetMapParameterfvNV_(GLenum target, GLenum pname, IntPtr parameters);
-            public delegate void GetMapAttribParameterivNV_(GLenum target, GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetMapAttribParameterfvNV_(GLenum target, GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void EvalMapsNV(GLenum target, GLenum mode);
-            public delegate void CombinerStageParameterfvNV_(GLenum stage, GLenum pname, IntPtr parameters);
-            public delegate void GetCombinerStageParameterfvNV_(GLenum stage, GLenum pname, IntPtr parameters);
-            public delegate GLboolean AreProgramsResidentNV_(GLsizei n, IntPtr programs, IntPtr residences);
-            public delegate void BindProgramNV(GLenum target, GLuint id);
-            public delegate void DeleteProgramsNV_(GLsizei n, IntPtr programs);
-            public delegate void ExecuteProgramNV_(GLenum target, GLuint id, IntPtr parameters);
-            public delegate void GenProgramsNV_(GLsizei n, IntPtr programs);
-            public delegate void GetProgramParameterdvNV_(GLenum target, GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetProgramParameterfvNV_(GLenum target, GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetProgramivNV_(GLuint id, GLenum pname, IntPtr parameters);
-            public delegate void GetProgramStringNV_(GLuint id, GLenum pname, IntPtr program);
-            public delegate void GetTrackMatrixivNV_(GLenum target, GLuint address, GLenum pname, IntPtr parameters);
-            public delegate void GetVertexAttribdvNV_(GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetVertexAttribfvNV_(GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetVertexAttribivNV_(GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetVertexAttribPointervNV_(GLuint index, GLenum pname, IntPtr pointer);
-            public delegate GLboolean IsProgramNV(GLuint id);
-            public delegate void LoadProgramNV_(GLenum target, GLuint id, GLsizei len, IntPtr program);
-            public delegate void ProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-            public delegate void ProgramParameter4dvNV_(GLenum target, GLuint index, IntPtr v);
-            public delegate void ProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void ProgramParameter4fvNV_(GLenum target, GLuint index, IntPtr v);
-            public delegate void ProgramParameters4dvNV_(GLenum target, GLuint index, GLuint count, IntPtr v);
-            public delegate void ProgramParameters4fvNV_(GLenum target, GLuint index, GLuint count, IntPtr v);
-            public delegate void RequestResidentProgramsNV_(GLsizei n, IntPtr programs);
-            public delegate void TrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform);
-            public delegate void VertexAttribPointerNV_(GLuint index, GLint fsize, GLenum type, GLsizei stride, IntPtr pointer);
-            public delegate void VertexAttrib1dNV(GLuint index, GLdouble x);
-            public delegate void VertexAttrib1dvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib1fNV(GLuint index, GLfloat x);
-            public delegate void VertexAttrib1fvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib1sNV(GLuint index, GLshort x);
-            public delegate void VertexAttrib1svNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y);
-            public delegate void VertexAttrib2dvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y);
-            public delegate void VertexAttrib2fvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib2sNV(GLuint index, GLshort x, GLshort y);
-            public delegate void VertexAttrib2svNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-            public delegate void VertexAttrib3dvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void VertexAttrib3fvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z);
-            public delegate void VertexAttrib3svNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-            public delegate void VertexAttrib4dvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void VertexAttrib4fvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-            public delegate void VertexAttrib4svNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-            public delegate void VertexAttrib4ubvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttribs1dvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs1fvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs1svNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs2dvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs2fvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs2svNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs3dvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs3fvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs3svNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs4dvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs4fvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs4svNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void VertexAttribs4ubvNV_(GLuint index, GLsizei count, IntPtr v);
-            public delegate void TexBumpParameterivATI_(GLenum pname, IntPtr param);
-            public delegate void TexBumpParameterfvATI_(GLenum pname, IntPtr param);
-            public delegate void GetTexBumpParameterivATI_(GLenum pname, IntPtr param);
-            public delegate void GetTexBumpParameterfvATI_(GLenum pname, IntPtr param);
-            public delegate GLuint GenFragmentShadersATI(GLuint range);
-            public delegate void BindFragmentShaderATI(GLuint id);
-            public delegate void DeleteFragmentShaderATI(GLuint id);
-            public delegate void BeginFragmentShaderATI();
-            public delegate void EndFragmentShaderATI();
-            public delegate void PassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle);
-            public delegate void SampleMapATI(GLuint dst, GLuint interp, GLenum swizzle);
-            public delegate void ColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
-            public delegate void ColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
-            public delegate void ColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
-            public delegate void AlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
-            public delegate void AlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
-            public delegate void AlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
-            public delegate void SetFragmentShaderConstantATI_(GLuint dst, IntPtr value);
-            public delegate void PNTrianglesiATI(GLenum pname, GLint param);
-            public delegate void PNTrianglesfATI(GLenum pname, GLfloat param);
-            public delegate GLuint NewObjectBufferATI_(GLsizei size, IntPtr pointer, GLenum usage);
-            public delegate GLboolean IsObjectBufferATI(GLuint buffer);
-            public delegate void UpdateObjectBufferATI_(GLuint buffer, GLuint offset, GLsizei size, IntPtr pointer, GLenum preserve);
-            public delegate void GetObjectBufferfvATI_(GLuint buffer, GLenum pname, IntPtr parameters);
-            public delegate void GetObjectBufferivATI_(GLuint buffer, GLenum pname, IntPtr parameters);
-            public delegate void FreeObjectBufferATI(GLuint buffer);
-            public delegate void ArrayObjectATI(Enums.EnableCap array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
-            public delegate void GetArrayObjectfvATI_(Enums.EnableCap array, GLenum pname, IntPtr parameters);
-            public delegate void GetArrayObjectivATI_(Enums.EnableCap array, GLenum pname, IntPtr parameters);
-            public delegate void VariantArrayObjectATI(GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
-            public delegate void GetVariantArrayObjectfvATI_(GLuint id, GLenum pname, IntPtr parameters);
-            public delegate void GetVariantArrayObjectivATI_(GLuint id, GLenum pname, IntPtr parameters);
-            public delegate void BeginVertexShaderEXT();
-            public delegate void EndVertexShaderEXT();
-            public delegate void BindVertexShaderEXT(GLuint id);
-            public delegate GLuint GenVertexShadersEXT(GLuint range);
-            public delegate void DeleteVertexShaderEXT(GLuint id);
-            public delegate void ShaderOp1EXT(GLenum op, GLuint res, GLuint arg1);
-            public delegate void ShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2);
-            public delegate void ShaderOp3EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
-            public delegate void SwizzleEXT(GLuint res, GLuint @in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
-            public delegate void WriteMaskEXT(GLuint res, GLuint @in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
-            public delegate void InsertComponentEXT(GLuint res, GLuint src, GLuint num);
-            public delegate void ExtractComponentEXT(GLuint res, GLuint src, GLuint num);
-            public delegate GLuint GenSymbolsEXT(GLenum datatype, GLenum storagetype, GLenum range, GLuint components);
-            public delegate void SetInvariantEXT_(GLuint id, GLenum type, IntPtr addr);
-            public delegate void SetLocalConstantEXT_(GLuint id, GLenum type, IntPtr addr);
-            public delegate void VariantbvEXT_(GLuint id, IntPtr addr);
-            public delegate void VariantsvEXT_(GLuint id, IntPtr addr);
-            public delegate void VariantivEXT_(GLuint id, IntPtr addr);
-            public delegate void VariantfvEXT_(GLuint id, IntPtr addr);
-            public delegate void VariantdvEXT_(GLuint id, IntPtr addr);
-            public delegate void VariantubvEXT_(GLuint id, IntPtr addr);
-            public delegate void VariantusvEXT_(GLuint id, IntPtr addr);
-            public delegate void VariantuivEXT_(GLuint id, IntPtr addr);
-            public delegate void VariantPointerEXT_(GLuint id, GLenum type, GLuint stride, IntPtr addr);
-            public delegate void EnableVariantClientStateEXT(GLuint id);
-            public delegate void DisableVariantClientStateEXT(GLuint id);
-            public delegate GLuint BindLightParameterEXT(Enums.LightName light, Enums.LightParameter value);
-            public delegate GLuint BindMaterialParameterEXT(Enums.MaterialFace face, Enums.MaterialParameter value);
-            public delegate GLuint BindTexGenParameterEXT(GLenum unit, Enums.TextureCoordName coord, Enums.TextureGenParameter value);
-            public delegate GLuint BindTextureUnitParameterEXT(GLenum unit, GLenum value);
-            public delegate GLuint BindParameterEXT(GLenum value);
-            public delegate GLboolean IsVariantEnabledEXT(GLuint id, GLenum cap);
-            public delegate void GetVariantBooleanvEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetVariantIntegervEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetVariantFloatvEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetVariantPointervEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetInvariantBooleanvEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetInvariantIntegervEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetInvariantFloatvEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetLocalConstantBooleanvEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetLocalConstantIntegervEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void GetLocalConstantFloatvEXT_(GLuint id, GLenum value, IntPtr data);
-            public delegate void VertexStream1sATI(GLenum stream, GLshort x);
-            public delegate void VertexStream1svATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream1iATI(GLenum stream, GLint x);
-            public delegate void VertexStream1ivATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream1fATI(GLenum stream, GLfloat x);
-            public delegate void VertexStream1fvATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream1dATI(GLenum stream, GLdouble x);
-            public delegate void VertexStream1dvATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream2sATI(GLenum stream, GLshort x, GLshort y);
-            public delegate void VertexStream2svATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream2iATI(GLenum stream, GLint x, GLint y);
-            public delegate void VertexStream2ivATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream2fATI(GLenum stream, GLfloat x, GLfloat y);
-            public delegate void VertexStream2fvATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream2dATI(GLenum stream, GLdouble x, GLdouble y);
-            public delegate void VertexStream2dvATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream3sATI(GLenum stream, GLshort x, GLshort y, GLshort z);
-            public delegate void VertexStream3svATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z);
-            public delegate void VertexStream3ivATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z);
-            public delegate void VertexStream3fvATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z);
-            public delegate void VertexStream3dvATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream4sATI(GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
-            public delegate void VertexStream4svATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w);
-            public delegate void VertexStream4ivATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void VertexStream4fvATI_(GLenum stream, IntPtr coords);
-            public delegate void VertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-            public delegate void VertexStream4dvATI_(GLenum stream, IntPtr coords);
-            public delegate void NormalStream3bATI(GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz);
-            public delegate void NormalStream3bvATI_(GLenum stream, IntPtr coords);
-            public delegate void NormalStream3sATI(GLenum stream, GLshort nx, GLshort ny, GLshort nz);
-            public delegate void NormalStream3svATI_(GLenum stream, IntPtr coords);
-            public delegate void NormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz);
-            public delegate void NormalStream3ivATI_(GLenum stream, IntPtr coords);
-            public delegate void NormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz);
-            public delegate void NormalStream3fvATI_(GLenum stream, IntPtr coords);
-            public delegate void NormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz);
-            public delegate void NormalStream3dvATI_(GLenum stream, IntPtr coords);
-            public delegate void ClientActiveVertexStreamATI(GLenum stream);
-            public delegate void VertexBlendEnviATI(GLenum pname, GLint param);
-            public delegate void VertexBlendEnvfATI(GLenum pname, GLfloat param);
-            public delegate void ElementPointerATI_(GLenum type, IntPtr pointer);
-            public delegate void DrawElementArrayATI(Enums.BeginMode mode, GLsizei count);
-            public delegate void DrawRangeElementArrayATI(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count);
-            public delegate void DrawMeshArraysSUN(Enums.BeginMode mode, GLint first, GLsizei count, GLsizei width);
-            public delegate void GenOcclusionQueriesNV_(GLsizei n, IntPtr ids);
-            public delegate void DeleteOcclusionQueriesNV_(GLsizei n, IntPtr ids);
-            public delegate GLboolean IsOcclusionQueryNV(GLuint id);
-            public delegate void BeginOcclusionQueryNV(GLuint id);
-            public delegate void EndOcclusionQueryNV();
-            public delegate void GetOcclusionQueryivNV_(GLuint id, GLenum pname, IntPtr parameters);
-            public delegate void GetOcclusionQueryuivNV_(GLuint id, GLenum pname, IntPtr parameters);
-            public delegate void PointParameteriNV(GLenum pname, GLint param);
-            public delegate void PointParameterivNV_(GLenum pname, IntPtr parameters);
-            public delegate void ActiveStencilFaceEXT(GLenum face);
-            public delegate void ElementPointerAPPLE_(GLenum type, IntPtr pointer);
-            public delegate void DrawElementArrayAPPLE(Enums.BeginMode mode, GLint first, GLsizei count);
-            public delegate void DrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint first, GLsizei count);
-            public delegate void MultiDrawElementArrayAPPLE_(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount);
-            public delegate void MultiDrawRangeElementArrayAPPLE_(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, IntPtr count, GLsizei primcount);
-            public delegate void GenFencesAPPLE_(GLsizei n, IntPtr fences);
-            public delegate void DeleteFencesAPPLE_(GLsizei n, IntPtr fences);
-            public delegate void SetFenceAPPLE(GLuint fence);
-            public delegate GLboolean IsFenceAPPLE(GLuint fence);
-            public delegate GLboolean TestFenceAPPLE(GLuint fence);
-            public delegate void FinishFenceAPPLE(GLuint fence);
-            public delegate GLboolean TestObjectAPPLE(GLenum @object, GLuint name);
-            public delegate void FinishObjectAPPLE(GLenum @object, GLint name);
-            public delegate void BindVertexArrayAPPLE(GLuint array);
-            public delegate void DeleteVertexArraysAPPLE_(GLsizei n, IntPtr arrays);
-            public delegate void GenVertexArraysAPPLE_(GLsizei n, IntPtr arrays);
-            public delegate GLboolean IsVertexArrayAPPLE(GLuint array);
-            public delegate void VertexArrayRangeAPPLE_(GLsizei length, IntPtr pointer);
-            public delegate void FlushVertexArrayRangeAPPLE_(GLsizei length, IntPtr pointer);
-            public delegate void VertexArrayParameteriAPPLE(GLenum pname, GLint param);
-            public delegate void DrawBuffersATI_(GLsizei n, IntPtr bufs);
-            public delegate void ProgramNamedParameter4fNV_(GLuint id, GLsizei len, IntPtr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-            public delegate void ProgramNamedParameter4dNV_(GLuint id, GLsizei len, IntPtr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-            public delegate void ProgramNamedParameter4fvNV_(GLuint id, GLsizei len, IntPtr name, IntPtr v);
-            public delegate void ProgramNamedParameter4dvNV_(GLuint id, GLsizei len, IntPtr name, IntPtr v);
-            public delegate void GetProgramNamedParameterfvNV_(GLuint id, GLsizei len, IntPtr name, IntPtr parameters);
-            public delegate void GetProgramNamedParameterdvNV_(GLuint id, GLsizei len, IntPtr name, IntPtr parameters);
-            public delegate void Vertex2hNV(GLhalfNV x, GLhalfNV y);
-            public delegate void Vertex2hvNV_(IntPtr v);
-            public delegate void Vertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z);
-            public delegate void Vertex3hvNV_(IntPtr v);
-            public delegate void Vertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
-            public delegate void Vertex4hvNV_(IntPtr v);
-            public delegate void Normal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz);
-            public delegate void Normal3hvNV_(IntPtr v);
-            public delegate void Color3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue);
-            public delegate void Color3hvNV_(IntPtr v);
-            public delegate void Color4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha);
-            public delegate void Color4hvNV_(IntPtr v);
-            public delegate void TexCoord1hNV(GLhalfNV s);
-            public delegate void TexCoord1hvNV_(IntPtr v);
-            public delegate void TexCoord2hNV(GLhalfNV s, GLhalfNV t);
-            public delegate void TexCoord2hvNV_(IntPtr v);
-            public delegate void TexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r);
-            public delegate void TexCoord3hvNV_(IntPtr v);
-            public delegate void TexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
-            public delegate void TexCoord4hvNV_(IntPtr v);
-            public delegate void MultiTexCoord1hNV(GLenum target, GLhalfNV s);
-            public delegate void MultiTexCoord1hvNV_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord2hNV(GLenum target, GLhalfNV s, GLhalfNV t);
-            public delegate void MultiTexCoord2hvNV_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord3hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r);
-            public delegate void MultiTexCoord3hvNV_(GLenum target, IntPtr v);
-            public delegate void MultiTexCoord4hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
-            public delegate void MultiTexCoord4hvNV_(GLenum target, IntPtr v);
-            public delegate void FogCoordhNV(GLhalfNV fog);
-            public delegate void FogCoordhvNV_(IntPtr fog);
-            public delegate void SecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue);
-            public delegate void SecondaryColor3hvNV_(IntPtr v);
-            public delegate void VertexWeighthNV(GLhalfNV weight);
-            public delegate void VertexWeighthvNV_(IntPtr weight);
-            public delegate void VertexAttrib1hNV(GLuint index, GLhalfNV x);
-            public delegate void VertexAttrib1hvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y);
-            public delegate void VertexAttrib2hvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z);
-            public delegate void VertexAttrib3hvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
-            public delegate void VertexAttrib4hvNV_(GLuint index, IntPtr v);
-            public delegate void VertexAttribs1hvNV_(GLuint index, GLsizei n, IntPtr v);
-            public delegate void VertexAttribs2hvNV_(GLuint index, GLsizei n, IntPtr v);
-            public delegate void VertexAttribs3hvNV_(GLuint index, GLsizei n, IntPtr v);
-            public delegate void VertexAttribs4hvNV_(GLuint index, GLsizei n, IntPtr v);
-            public delegate void PixelDataRangeNV_(GLenum target, GLsizei length, IntPtr pointer);
-            public delegate void FlushPixelDataRangeNV(GLenum target);
-            public delegate void PrimitiveRestartNV();
-            public delegate void PrimitiveRestartIndexNV(GLuint index);
-            public delegate IntPtr MapObjectBufferATI(GLuint buffer);
-            public delegate void UnmapObjectBufferATI(GLuint buffer);
-            public delegate void StencilOpSeparateATI(GLenum face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass);
-            public delegate void StencilFuncSeparateATI(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint reference, GLuint mask);
-            public delegate void VertexAttribArrayObjectATI(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
-            public delegate void GetVertexAttribArrayObjectfvATI_(GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void GetVertexAttribArrayObjectivATI_(GLuint index, GLenum pname, IntPtr parameters);
-            public delegate void DepthBoundsEXT(GLclampd zmin, GLclampd zmax);
-            public delegate void BlendEquationSeparateEXT(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha);
-            public delegate GLboolean IsRenderbufferEXT(GLuint renderbuffer);
-            public delegate void BindRenderbufferEXT(Enums.EXT_framebuffer_object target, GLuint renderbuffer);
-            public delegate void DeleteRenderbuffersEXT_(GLsizei n, IntPtr renderbuffers);
-            public delegate void GenRenderbuffersEXT_(GLsizei n, IntPtr renderbuffers);
-            public delegate void RenderbufferStorageEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object internalformat, GLsizei width, GLsizei height);
-            public delegate void GetRenderbufferParameterivEXT_(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, IntPtr parameters);
-            public delegate GLboolean IsFramebufferEXT(GLuint framebuffer);
-            public delegate void BindFramebufferEXT(Enums.EXT_framebuffer_object target, GLuint framebuffer);
-            public delegate void DeleteFramebuffersEXT_(GLsizei n, IntPtr framebuffers);
-            public delegate void GenFramebuffersEXT_(GLsizei n, IntPtr framebuffers);
-            public delegate GLenum CheckFramebufferStatusEXT(Enums.EXT_framebuffer_object target);
-            public delegate void FramebufferTexture1DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level);
-            public delegate void FramebufferTexture2DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level);
-            public delegate void FramebufferTexture3DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level, GLint zoffset);
-            public delegate void FramebufferRenderbufferEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object renderbuffertarget, GLuint renderbuffer);
-            public delegate void GetFramebufferAttachmentParameterivEXT_(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, IntPtr parameters);
-            public delegate void GenerateMipmapEXT(Enums.EXT_framebuffer_object target);
-            public delegate void StringMarkerGREMEDY_(GLsizei len, IntPtr @string);
-            public delegate void StencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag);
-            public delegate void BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, Enums.ClearBufferMask mask, Enums.EXT_framebuffer_blit filter);
-            public delegate void RenderbufferStorageMultisampleEXT(Enums.EXT_framebuffer_multisample target, GLsizei samples, Enums.EXT_framebuffer_multisample internalformat, GLsizei width, GLsizei height);
-            public delegate void GetQueryObjecti64vEXT_(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters);
-            public delegate void GetQueryObjectui64vEXT_(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters);
-            public delegate void ProgramEnvParameters4fvEXT_(GLenum target, GLuint index, GLsizei count, IntPtr parameters);
-            public delegate void ProgramLocalParameters4fvEXT_(GLenum target, GLuint index, GLsizei count, IntPtr parameters);
+            public delegate void VertexAttribPointer_(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer);
+            public delegate void UniformMatrix2x3fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix3x2fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix2x4fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix4x2fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix3x4fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix4x3fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
         }
         #endregion
 
@@ -6762,7 +723,7 @@ namespace OpenTK.OpenGL
             [DllImport("opengl32.dll", EntryPoint = "glColor4usv")]
             public static extern void Color4usv_(IntPtr v);
             [DllImport("opengl32.dll", EntryPoint = "glEdgeFlag")]
-            public static extern void EdgeFlag(GLboolean flag);
+            public static extern void EdgeFlag(Enums.Boolean flag);
             [DllImport("opengl32.dll", EntryPoint = "glEdgeFlagv")]
             public static extern void EdgeFlagv_(IntPtr flag);
             [DllImport("opengl32.dll", EntryPoint = "glEnd")]
@@ -7100,9 +1061,9 @@ namespace OpenTK.OpenGL
             [DllImport("opengl32.dll", EntryPoint = "glStencilMask")]
             public static extern void StencilMask(GLuint mask);
             [DllImport("opengl32.dll", EntryPoint = "glColorMask")]
-            public static extern void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+            public static extern void ColorMask(Enums.Boolean red, Enums.Boolean green, Enums.Boolean blue, Enums.Boolean alpha);
             [DllImport("opengl32.dll", EntryPoint = "glDepthMask")]
-            public static extern void DepthMask(GLboolean flag);
+            public static extern void DepthMask(Enums.Boolean flag);
             [DllImport("opengl32.dll", EntryPoint = "glIndexMask")]
             public static extern void IndexMask(GLuint mask);
             [DllImport("opengl32.dll", EntryPoint = "glAccum")]
@@ -7402,21 +1363,21 @@ namespace OpenTK.OpenGL
             [DllImport("opengl32.dll", EntryPoint = "glSeparableFilter2D")]
             public static extern void SeparableFilter2D_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column);
             [DllImport("opengl32.dll", EntryPoint = "glGetHistogram")]
-            public static extern void GetHistogram_(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
+            public static extern void GetHistogram_(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
             [DllImport("opengl32.dll", EntryPoint = "glGetHistogramParameterfv")]
             public static extern void GetHistogramParameterfv_(GLenum target, GLenum pname, IntPtr parameters);
             [DllImport("opengl32.dll", EntryPoint = "glGetHistogramParameteriv")]
             public static extern void GetHistogramParameteriv_(GLenum target, GLenum pname, IntPtr parameters);
             [DllImport("opengl32.dll", EntryPoint = "glGetMinmax")]
-            public static extern void GetMinmax_(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
+            public static extern void GetMinmax_(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
             [DllImport("opengl32.dll", EntryPoint = "glGetMinmaxParameterfv")]
             public static extern void GetMinmaxParameterfv_(GLenum target, GLenum pname, IntPtr parameters);
             [DllImport("opengl32.dll", EntryPoint = "glGetMinmaxParameteriv")]
             public static extern void GetMinmaxParameteriv_(GLenum target, GLenum pname, IntPtr parameters);
             [DllImport("opengl32.dll", EntryPoint = "glHistogram")]
-            public static extern void Histogram(GLenum target, GLsizei width, Enums.PixelInternalFormat internalformat, GLboolean sink);
+            public static extern void Histogram(GLenum target, GLsizei width, Enums.PixelInternalFormat internalformat, Enums.Boolean sink);
             [DllImport("opengl32.dll", EntryPoint = "glMinmax")]
-            public static extern void Minmax(GLenum target, Enums.PixelInternalFormat internalformat, GLboolean sink);
+            public static extern void Minmax(GLenum target, Enums.PixelInternalFormat internalformat, Enums.Boolean sink);
             [DllImport("opengl32.dll", EntryPoint = "glResetHistogram")]
             public static extern void ResetHistogram(GLenum target);
             [DllImport("opengl32.dll", EntryPoint = "glResetMinmax")]
@@ -7504,7 +1465,7 @@ namespace OpenTK.OpenGL
             [DllImport("opengl32.dll", EntryPoint = "glMultTransposeMatrixd")]
             public static extern void MultTransposeMatrixd_(IntPtr m);
             [DllImport("opengl32.dll", EntryPoint = "glSampleCoverage")]
-            public static extern void SampleCoverage(GLclampf value, GLboolean invert);
+            public static extern void SampleCoverage(GLclampf value, Enums.Boolean invert);
             [DllImport("opengl32.dll", EntryPoint = "glCompressedTexImage3D")]
             public static extern void CompressedTexImage3D_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data);
             [DllImport("opengl32.dll", EntryPoint = "glCompressedTexImage2D")]
@@ -7752,11 +1713,11 @@ namespace OpenTK.OpenGL
             [DllImport("opengl32.dll", EntryPoint = "glUniform4iv")]
             public static extern void Uniform4iv_(GLint location, GLsizei count, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix2fv")]
-            public static extern void UniformMatrix2fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix2fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix3fv")]
-            public static extern void UniformMatrix3fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix3fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix4fv")]
-            public static extern void UniformMatrix4fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix4fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glValidateProgram")]
             public static extern void ValidateProgram(GLuint program);
             [DllImport("opengl32.dll", EntryPoint = "glVertexAttrib1d")]
@@ -7832,1459 +1793,607 @@ namespace OpenTK.OpenGL
             [DllImport("opengl32.dll", EntryPoint = "glVertexAttrib4usv")]
             public static extern void VertexAttrib4usv_(GLuint index, IntPtr v);
             [DllImport("opengl32.dll", EntryPoint = "glVertexAttribPointer")]
-            public static extern void VertexAttribPointer_(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, IntPtr pointer);
+            public static extern void VertexAttribPointer_(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix2x3fv")]
-            public static extern void UniformMatrix2x3fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix2x3fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix3x2fv")]
-            public static extern void UniformMatrix3x2fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix3x2fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix2x4fv")]
-            public static extern void UniformMatrix2x4fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix2x4fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix4x2fv")]
-            public static extern void UniformMatrix4x2fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix4x2fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix3x4fv")]
-            public static extern void UniformMatrix3x4fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix3x4fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
             [DllImport("opengl32.dll", EntryPoint = "glUniformMatrix4x3fv")]
-            public static extern void UniformMatrix4x3fv_(GLint location, GLsizei count, GLboolean transpose, IntPtr value);
+            public static extern void UniformMatrix4x3fv_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
         }
         #endregion
 
-        #region Function initialisation
+        #region Static Functions (and static initialisation)
 
-        public static Delegates.NewList NewList;
-        public static Delegates.EndList EndList;
-        public static Delegates.CallList CallList;
-        public static Delegates.CallLists_ CallLists_;
-        public static Delegates.DeleteLists DeleteLists;
-        public static Delegates.GenLists GenLists;
-        public static Delegates.ListBase ListBase;
-        public static Delegates.Begin Begin;
-        public static Delegates.Bitmap_ Bitmap_;
-        public static Delegates.Color3b Color3b;
-        public static Delegates.Color3bv_ Color3bv_;
-        public static Delegates.Color3d Color3d;
-        public static Delegates.Color3dv_ Color3dv_;
-        public static Delegates.Color3f Color3f;
-        public static Delegates.Color3fv_ Color3fv_;
-        public static Delegates.Color3i Color3i;
-        public static Delegates.Color3iv_ Color3iv_;
-        public static Delegates.Color3s Color3s;
-        public static Delegates.Color3sv_ Color3sv_;
-        public static Delegates.Color3ub Color3ub;
-        public static Delegates.Color3ubv_ Color3ubv_;
-        public static Delegates.Color3ui Color3ui;
-        public static Delegates.Color3uiv_ Color3uiv_;
-        public static Delegates.Color3us Color3us;
-        public static Delegates.Color3usv_ Color3usv_;
-        public static Delegates.Color4b Color4b;
-        public static Delegates.Color4bv_ Color4bv_;
-        public static Delegates.Color4d Color4d;
-        public static Delegates.Color4dv_ Color4dv_;
-        public static Delegates.Color4f Color4f;
-        public static Delegates.Color4fv_ Color4fv_;
-        public static Delegates.Color4i Color4i;
-        public static Delegates.Color4iv_ Color4iv_;
-        public static Delegates.Color4s Color4s;
-        public static Delegates.Color4sv_ Color4sv_;
-        public static Delegates.Color4ub Color4ub;
-        public static Delegates.Color4ubv_ Color4ubv_;
-        public static Delegates.Color4ui Color4ui;
-        public static Delegates.Color4uiv_ Color4uiv_;
-        public static Delegates.Color4us Color4us;
-        public static Delegates.Color4usv_ Color4usv_;
-        public static Delegates.EdgeFlag EdgeFlag;
-        public static Delegates.EdgeFlagv_ EdgeFlagv_;
-        public static Delegates.End End;
-        public static Delegates.Indexd Indexd;
-        public static Delegates.Indexdv_ Indexdv_;
-        public static Delegates.Indexf Indexf;
-        public static Delegates.Indexfv_ Indexfv_;
-        public static Delegates.Indexi Indexi;
-        public static Delegates.Indexiv_ Indexiv_;
-        public static Delegates.Indexs Indexs;
-        public static Delegates.Indexsv_ Indexsv_;
-        public static Delegates.Normal3b Normal3b;
-        public static Delegates.Normal3bv_ Normal3bv_;
-        public static Delegates.Normal3d Normal3d;
-        public static Delegates.Normal3dv_ Normal3dv_;
-        public static Delegates.Normal3f Normal3f;
-        public static Delegates.Normal3fv_ Normal3fv_;
-        public static Delegates.Normal3i Normal3i;
-        public static Delegates.Normal3iv_ Normal3iv_;
-        public static Delegates.Normal3s Normal3s;
-        public static Delegates.Normal3sv_ Normal3sv_;
-        public static Delegates.RasterPos2d RasterPos2d;
-        public static Delegates.RasterPos2dv_ RasterPos2dv_;
-        public static Delegates.RasterPos2f RasterPos2f;
-        public static Delegates.RasterPos2fv_ RasterPos2fv_;
-        public static Delegates.RasterPos2i RasterPos2i;
-        public static Delegates.RasterPos2iv_ RasterPos2iv_;
-        public static Delegates.RasterPos2s RasterPos2s;
-        public static Delegates.RasterPos2sv_ RasterPos2sv_;
-        public static Delegates.RasterPos3d RasterPos3d;
-        public static Delegates.RasterPos3dv_ RasterPos3dv_;
-        public static Delegates.RasterPos3f RasterPos3f;
-        public static Delegates.RasterPos3fv_ RasterPos3fv_;
-        public static Delegates.RasterPos3i RasterPos3i;
-        public static Delegates.RasterPos3iv_ RasterPos3iv_;
-        public static Delegates.RasterPos3s RasterPos3s;
-        public static Delegates.RasterPos3sv_ RasterPos3sv_;
-        public static Delegates.RasterPos4d RasterPos4d;
-        public static Delegates.RasterPos4dv_ RasterPos4dv_;
-        public static Delegates.RasterPos4f RasterPos4f;
-        public static Delegates.RasterPos4fv_ RasterPos4fv_;
-        public static Delegates.RasterPos4i RasterPos4i;
-        public static Delegates.RasterPos4iv_ RasterPos4iv_;
-        public static Delegates.RasterPos4s RasterPos4s;
-        public static Delegates.RasterPos4sv_ RasterPos4sv_;
-        public static Delegates.Rectd Rectd;
-        public static Delegates.Rectdv_ Rectdv_;
-        public static Delegates.Rectf Rectf;
-        public static Delegates.Rectfv_ Rectfv_;
-        public static Delegates.Recti Recti;
-        public static Delegates.Rectiv_ Rectiv_;
-        public static Delegates.Rects Rects;
-        public static Delegates.Rectsv_ Rectsv_;
-        public static Delegates.TexCoord1d TexCoord1d;
-        public static Delegates.TexCoord1dv_ TexCoord1dv_;
-        public static Delegates.TexCoord1f TexCoord1f;
-        public static Delegates.TexCoord1fv_ TexCoord1fv_;
-        public static Delegates.TexCoord1i TexCoord1i;
-        public static Delegates.TexCoord1iv_ TexCoord1iv_;
-        public static Delegates.TexCoord1s TexCoord1s;
-        public static Delegates.TexCoord1sv_ TexCoord1sv_;
-        public static Delegates.TexCoord2d TexCoord2d;
-        public static Delegates.TexCoord2dv_ TexCoord2dv_;
-        public static Delegates.TexCoord2f TexCoord2f;
-        public static Delegates.TexCoord2fv_ TexCoord2fv_;
-        public static Delegates.TexCoord2i TexCoord2i;
-        public static Delegates.TexCoord2iv_ TexCoord2iv_;
-        public static Delegates.TexCoord2s TexCoord2s;
-        public static Delegates.TexCoord2sv_ TexCoord2sv_;
-        public static Delegates.TexCoord3d TexCoord3d;
-        public static Delegates.TexCoord3dv_ TexCoord3dv_;
-        public static Delegates.TexCoord3f TexCoord3f;
-        public static Delegates.TexCoord3fv_ TexCoord3fv_;
-        public static Delegates.TexCoord3i TexCoord3i;
-        public static Delegates.TexCoord3iv_ TexCoord3iv_;
-        public static Delegates.TexCoord3s TexCoord3s;
-        public static Delegates.TexCoord3sv_ TexCoord3sv_;
-        public static Delegates.TexCoord4d TexCoord4d;
-        public static Delegates.TexCoord4dv_ TexCoord4dv_;
-        public static Delegates.TexCoord4f TexCoord4f;
-        public static Delegates.TexCoord4fv_ TexCoord4fv_;
-        public static Delegates.TexCoord4i TexCoord4i;
-        public static Delegates.TexCoord4iv_ TexCoord4iv_;
-        public static Delegates.TexCoord4s TexCoord4s;
-        public static Delegates.TexCoord4sv_ TexCoord4sv_;
-        public static Delegates.Vertex2d Vertex2d;
-        public static Delegates.Vertex2dv_ Vertex2dv_;
-        public static Delegates.Vertex2f Vertex2f;
-        public static Delegates.Vertex2fv_ Vertex2fv_;
-        public static Delegates.Vertex2i Vertex2i;
-        public static Delegates.Vertex2iv_ Vertex2iv_;
-        public static Delegates.Vertex2s Vertex2s;
-        public static Delegates.Vertex2sv_ Vertex2sv_;
-        public static Delegates.Vertex3d Vertex3d;
-        public static Delegates.Vertex3dv_ Vertex3dv_;
-        public static Delegates.Vertex3f Vertex3f;
-        public static Delegates.Vertex3fv_ Vertex3fv_;
-        public static Delegates.Vertex3i Vertex3i;
-        public static Delegates.Vertex3iv_ Vertex3iv_;
-        public static Delegates.Vertex3s Vertex3s;
-        public static Delegates.Vertex3sv_ Vertex3sv_;
-        public static Delegates.Vertex4d Vertex4d;
-        public static Delegates.Vertex4dv_ Vertex4dv_;
-        public static Delegates.Vertex4f Vertex4f;
-        public static Delegates.Vertex4fv_ Vertex4fv_;
-        public static Delegates.Vertex4i Vertex4i;
-        public static Delegates.Vertex4iv_ Vertex4iv_;
-        public static Delegates.Vertex4s Vertex4s;
-        public static Delegates.Vertex4sv_ Vertex4sv_;
-        public static Delegates.ClipPlane_ ClipPlane_;
-        public static Delegates.ColorMaterial ColorMaterial;
-        public static Delegates.CullFace CullFace;
-        public static Delegates.Fogf Fogf;
-        public static Delegates.Fogfv_ Fogfv_;
-        public static Delegates.Fogi Fogi;
-        public static Delegates.Fogiv_ Fogiv_;
-        public static Delegates.FrontFace FrontFace;
-        public static Delegates.Hint Hint;
-        public static Delegates.Lightf Lightf;
-        public static Delegates.Lightfv_ Lightfv_;
-        public static Delegates.Lighti Lighti;
-        public static Delegates.Lightiv_ Lightiv_;
-        public static Delegates.LightModelf LightModelf;
-        public static Delegates.LightModelfv_ LightModelfv_;
-        public static Delegates.LightModeli LightModeli;
-        public static Delegates.LightModeliv_ LightModeliv_;
-        public static Delegates.LineStipple_ LineStipple_;
-        public static Delegates.LineWidth LineWidth;
-        public static Delegates.Materialf Materialf;
-        public static Delegates.Materialfv_ Materialfv_;
-        public static Delegates.Materiali Materiali;
-        public static Delegates.Materialiv_ Materialiv_;
-        public static Delegates.PointSize PointSize;
-        public static Delegates.PolygonMode PolygonMode;
-        public static Delegates.PolygonStipple_ PolygonStipple_;
-        public static Delegates.Scissor Scissor;
-        public static Delegates.ShadeModel ShadeModel;
-        public static Delegates.TexParameterf TexParameterf;
-        public static Delegates.TexParameterfv_ TexParameterfv_;
-        public static Delegates.TexParameteri TexParameteri;
-        public static Delegates.TexParameteriv_ TexParameteriv_;
-        public static Delegates.TexImage1D_ TexImage1D_;
-        public static Delegates.TexImage2D_ TexImage2D_;
-        public static Delegates.TexEnvf TexEnvf;
-        public static Delegates.TexEnvfv_ TexEnvfv_;
-        public static Delegates.TexEnvi TexEnvi;
-        public static Delegates.TexEnviv_ TexEnviv_;
-        public static Delegates.TexGend TexGend;
-        public static Delegates.TexGendv_ TexGendv_;
-        public static Delegates.TexGenf TexGenf;
-        public static Delegates.TexGenfv_ TexGenfv_;
-        public static Delegates.TexGeni TexGeni;
-        public static Delegates.TexGeniv_ TexGeniv_;
-        public static Delegates.FeedbackBuffer_ FeedbackBuffer_;
-        public static Delegates.SelectBuffer_ SelectBuffer_;
-        public static Delegates.RenderMode RenderMode;
-        public static Delegates.InitNames InitNames;
-        public static Delegates.LoadName LoadName;
-        public static Delegates.PassThrough PassThrough;
-        public static Delegates.PopName PopName;
-        public static Delegates.PushName PushName;
-        public static Delegates.DrawBuffer DrawBuffer;
-        public static Delegates.Clear Clear;
-        public static Delegates.ClearAccum ClearAccum;
-        public static Delegates.ClearIndex ClearIndex;
-        public static Delegates.ClearColor ClearColor;
-        public static Delegates.ClearStencil ClearStencil;
-        public static Delegates.ClearDepth ClearDepth;
-        public static Delegates.StencilMask StencilMask;
-        public static Delegates.ColorMask ColorMask;
-        public static Delegates.DepthMask DepthMask;
-        public static Delegates.IndexMask IndexMask;
-        public static Delegates.Accum Accum;
-        public static Delegates.Disable Disable;
-        public static Delegates.Enable Enable;
-        public static Delegates.Finish Finish;
-        public static Delegates.Flush Flush;
-        public static Delegates.PopAttrib PopAttrib;
-        public static Delegates.PushAttrib PushAttrib;
-        public static Delegates.Map1d_ Map1d_;
-        public static Delegates.Map1f_ Map1f_;
-        public static Delegates.Map2d_ Map2d_;
-        public static Delegates.Map2f_ Map2f_;
-        public static Delegates.MapGrid1d MapGrid1d;
-        public static Delegates.MapGrid1f MapGrid1f;
-        public static Delegates.MapGrid2d MapGrid2d;
-        public static Delegates.MapGrid2f MapGrid2f;
-        public static Delegates.EvalCoord1d EvalCoord1d;
-        public static Delegates.EvalCoord1dv_ EvalCoord1dv_;
-        public static Delegates.EvalCoord1f EvalCoord1f;
-        public static Delegates.EvalCoord1fv_ EvalCoord1fv_;
-        public static Delegates.EvalCoord2d EvalCoord2d;
-        public static Delegates.EvalCoord2dv_ EvalCoord2dv_;
-        public static Delegates.EvalCoord2f EvalCoord2f;
-        public static Delegates.EvalCoord2fv_ EvalCoord2fv_;
-        public static Delegates.EvalMesh1 EvalMesh1;
-        public static Delegates.EvalPoint1 EvalPoint1;
-        public static Delegates.EvalMesh2 EvalMesh2;
-        public static Delegates.EvalPoint2 EvalPoint2;
-        public static Delegates.AlphaFunc AlphaFunc;
-        public static Delegates.BlendFunc BlendFunc;
-        public static Delegates.LogicOp LogicOp;
-        public static Delegates.StencilFunc StencilFunc;
-        public static Delegates.StencilOp StencilOp;
-        public static Delegates.DepthFunc DepthFunc;
-        public static Delegates.PixelZoom PixelZoom;
-        public static Delegates.PixelTransferf PixelTransferf;
-        public static Delegates.PixelTransferi PixelTransferi;
-        public static Delegates.PixelStoref PixelStoref;
-        public static Delegates.PixelStorei PixelStorei;
-        public static Delegates.PixelMapfv_ PixelMapfv_;
-        public static Delegates.PixelMapuiv_ PixelMapuiv_;
-        public static Delegates.PixelMapusv_ PixelMapusv_;
-        public static Delegates.ReadBuffer ReadBuffer;
-        public static Delegates.CopyPixels CopyPixels;
-        public static Delegates.ReadPixels_ ReadPixels_;
-        public static Delegates.DrawPixels_ DrawPixels_;
-        public static Delegates.GetBooleanv_ GetBooleanv_;
-        public static Delegates.GetClipPlane_ GetClipPlane_;
-        public static Delegates.GetDoublev_ GetDoublev_;
-        public static Delegates.GetError GetError;
-        public static Delegates.GetFloatv_ GetFloatv_;
-        public static Delegates.GetIntegerv_ GetIntegerv_;
-        public static Delegates.GetLightfv_ GetLightfv_;
-        public static Delegates.GetLightiv_ GetLightiv_;
-        public static Delegates.GetMapdv_ GetMapdv_;
-        public static Delegates.GetMapfv_ GetMapfv_;
-        public static Delegates.GetMapiv_ GetMapiv_;
-        public static Delegates.GetMaterialfv_ GetMaterialfv_;
-        public static Delegates.GetMaterialiv_ GetMaterialiv_;
-        public static Delegates.GetPixelMapfv_ GetPixelMapfv_;
-        public static Delegates.GetPixelMapuiv_ GetPixelMapuiv_;
-        public static Delegates.GetPixelMapusv_ GetPixelMapusv_;
-        public static Delegates.GetPolygonStipple_ GetPolygonStipple_;
-        public static Delegates.GetString_ GetString_;
-        public static Delegates.GetTexEnvfv_ GetTexEnvfv_;
-        public static Delegates.GetTexEnviv_ GetTexEnviv_;
-        public static Delegates.GetTexGendv_ GetTexGendv_;
-        public static Delegates.GetTexGenfv_ GetTexGenfv_;
-        public static Delegates.GetTexGeniv_ GetTexGeniv_;
-        public static Delegates.GetTexImage_ GetTexImage_;
-        public static Delegates.GetTexParameterfv_ GetTexParameterfv_;
-        public static Delegates.GetTexParameteriv_ GetTexParameteriv_;
-        public static Delegates.GetTexLevelParameterfv_ GetTexLevelParameterfv_;
-        public static Delegates.GetTexLevelParameteriv_ GetTexLevelParameteriv_;
-        public static Delegates.IsEnabled IsEnabled;
-        public static Delegates.IsList IsList;
-        public static Delegates.DepthRange DepthRange;
-        public static Delegates.Frustum Frustum;
-        public static Delegates.LoadIdentity LoadIdentity;
-        public static Delegates.LoadMatrixf_ LoadMatrixf_;
-        public static Delegates.LoadMatrixd_ LoadMatrixd_;
-        public static Delegates.MatrixMode MatrixMode;
-        public static Delegates.MultMatrixf_ MultMatrixf_;
-        public static Delegates.MultMatrixd_ MultMatrixd_;
-        public static Delegates.Ortho Ortho;
-        public static Delegates.PopMatrix PopMatrix;
-        public static Delegates.PushMatrix PushMatrix;
-        public static Delegates.Rotated Rotated;
-        public static Delegates.Rotatef Rotatef;
-        public static Delegates.Scaled Scaled;
-        public static Delegates.Scalef Scalef;
-        public static Delegates.Translated Translated;
-        public static Delegates.Translatef Translatef;
-        public static Delegates.Viewport Viewport;
-        public static Delegates.ArrayElement ArrayElement;
-        public static Delegates.ColorPointer_ ColorPointer_;
-        public static Delegates.DisableClientState DisableClientState;
-        public static Delegates.DrawArrays DrawArrays;
-        public static Delegates.DrawElements_ DrawElements_;
-        public static Delegates.EdgeFlagPointer_ EdgeFlagPointer_;
-        public static Delegates.EnableClientState EnableClientState;
-        public static Delegates.GetPointerv_ GetPointerv_;
-        public static Delegates.IndexPointer_ IndexPointer_;
-        public static Delegates.InterleavedArrays_ InterleavedArrays_;
-        public static Delegates.NormalPointer_ NormalPointer_;
-        public static Delegates.TexCoordPointer_ TexCoordPointer_;
-        public static Delegates.VertexPointer_ VertexPointer_;
-        public static Delegates.PolygonOffset PolygonOffset;
-        public static Delegates.CopyTexImage1D CopyTexImage1D;
-        public static Delegates.CopyTexImage2D CopyTexImage2D;
-        public static Delegates.CopyTexSubImage1D CopyTexSubImage1D;
-        public static Delegates.CopyTexSubImage2D CopyTexSubImage2D;
-        public static Delegates.TexSubImage1D_ TexSubImage1D_;
-        public static Delegates.TexSubImage2D_ TexSubImage2D_;
-        public static Delegates.AreTexturesResident_ AreTexturesResident_;
-        public static Delegates.BindTexture BindTexture;
-        public static Delegates.DeleteTextures_ DeleteTextures_;
-        public static Delegates.GenTextures_ GenTextures_;
-        public static Delegates.IsTexture IsTexture;
-        public static Delegates.PrioritizeTextures_ PrioritizeTextures_;
-        public static Delegates.Indexub Indexub;
-        public static Delegates.Indexubv_ Indexubv_;
-        public static Delegates.PopClientAttrib PopClientAttrib;
-        public static Delegates.PushClientAttrib PushClientAttrib;
-        public static Delegates.BlendColor BlendColor;
-        public static Delegates.BlendEquation BlendEquation;
-        public static Delegates.DrawRangeElements_ DrawRangeElements_;
-        public static Delegates.ColorTable_ ColorTable_;
-        public static Delegates.ColorTableParameterfv_ ColorTableParameterfv_;
-        public static Delegates.ColorTableParameteriv_ ColorTableParameteriv_;
-        public static Delegates.CopyColorTable CopyColorTable;
-        public static Delegates.GetColorTable_ GetColorTable_;
-        public static Delegates.GetColorTableParameterfv_ GetColorTableParameterfv_;
-        public static Delegates.GetColorTableParameteriv_ GetColorTableParameteriv_;
-        public static Delegates.ColorSubTable_ ColorSubTable_;
-        public static Delegates.CopyColorSubTable CopyColorSubTable;
-        public static Delegates.ConvolutionFilter1D_ ConvolutionFilter1D_;
-        public static Delegates.ConvolutionFilter2D_ ConvolutionFilter2D_;
-        public static Delegates.ConvolutionParameterf ConvolutionParameterf;
-        public static Delegates.ConvolutionParameterfv_ ConvolutionParameterfv_;
-        public static Delegates.ConvolutionParameteri ConvolutionParameteri;
-        public static Delegates.ConvolutionParameteriv_ ConvolutionParameteriv_;
-        public static Delegates.CopyConvolutionFilter1D CopyConvolutionFilter1D;
-        public static Delegates.CopyConvolutionFilter2D CopyConvolutionFilter2D;
-        public static Delegates.GetConvolutionFilter_ GetConvolutionFilter_;
-        public static Delegates.GetConvolutionParameterfv_ GetConvolutionParameterfv_;
-        public static Delegates.GetConvolutionParameteriv_ GetConvolutionParameteriv_;
-        public static Delegates.GetSeparableFilter_ GetSeparableFilter_;
-        public static Delegates.SeparableFilter2D_ SeparableFilter2D_;
-        public static Delegates.GetHistogram_ GetHistogram_;
-        public static Delegates.GetHistogramParameterfv_ GetHistogramParameterfv_;
-        public static Delegates.GetHistogramParameteriv_ GetHistogramParameteriv_;
-        public static Delegates.GetMinmax_ GetMinmax_;
-        public static Delegates.GetMinmaxParameterfv_ GetMinmaxParameterfv_;
-        public static Delegates.GetMinmaxParameteriv_ GetMinmaxParameteriv_;
-        public static Delegates.Histogram Histogram;
-        public static Delegates.Minmax Minmax;
-        public static Delegates.ResetHistogram ResetHistogram;
-        public static Delegates.ResetMinmax ResetMinmax;
-        public static Delegates.TexImage3D_ TexImage3D_;
-        public static Delegates.TexSubImage3D_ TexSubImage3D_;
-        public static Delegates.CopyTexSubImage3D CopyTexSubImage3D;
-        public static Delegates.ActiveTexture ActiveTexture;
-        public static Delegates.ClientActiveTexture ClientActiveTexture;
-        public static Delegates.MultiTexCoord1d MultiTexCoord1d;
-        public static Delegates.MultiTexCoord1dv_ MultiTexCoord1dv_;
-        public static Delegates.MultiTexCoord1f MultiTexCoord1f;
-        public static Delegates.MultiTexCoord1fv_ MultiTexCoord1fv_;
-        public static Delegates.MultiTexCoord1i MultiTexCoord1i;
-        public static Delegates.MultiTexCoord1iv_ MultiTexCoord1iv_;
-        public static Delegates.MultiTexCoord1s MultiTexCoord1s;
-        public static Delegates.MultiTexCoord1sv_ MultiTexCoord1sv_;
-        public static Delegates.MultiTexCoord2d MultiTexCoord2d;
-        public static Delegates.MultiTexCoord2dv_ MultiTexCoord2dv_;
-        public static Delegates.MultiTexCoord2f MultiTexCoord2f;
-        public static Delegates.MultiTexCoord2fv_ MultiTexCoord2fv_;
-        public static Delegates.MultiTexCoord2i MultiTexCoord2i;
-        public static Delegates.MultiTexCoord2iv_ MultiTexCoord2iv_;
-        public static Delegates.MultiTexCoord2s MultiTexCoord2s;
-        public static Delegates.MultiTexCoord2sv_ MultiTexCoord2sv_;
-        public static Delegates.MultiTexCoord3d MultiTexCoord3d;
-        public static Delegates.MultiTexCoord3dv_ MultiTexCoord3dv_;
-        public static Delegates.MultiTexCoord3f MultiTexCoord3f;
-        public static Delegates.MultiTexCoord3fv_ MultiTexCoord3fv_;
-        public static Delegates.MultiTexCoord3i MultiTexCoord3i;
-        public static Delegates.MultiTexCoord3iv_ MultiTexCoord3iv_;
-        public static Delegates.MultiTexCoord3s MultiTexCoord3s;
-        public static Delegates.MultiTexCoord3sv_ MultiTexCoord3sv_;
-        public static Delegates.MultiTexCoord4d MultiTexCoord4d;
-        public static Delegates.MultiTexCoord4dv_ MultiTexCoord4dv_;
-        public static Delegates.MultiTexCoord4f MultiTexCoord4f;
-        public static Delegates.MultiTexCoord4fv_ MultiTexCoord4fv_;
-        public static Delegates.MultiTexCoord4i MultiTexCoord4i;
-        public static Delegates.MultiTexCoord4iv_ MultiTexCoord4iv_;
-        public static Delegates.MultiTexCoord4s MultiTexCoord4s;
-        public static Delegates.MultiTexCoord4sv_ MultiTexCoord4sv_;
-        public static Delegates.LoadTransposeMatrixf_ LoadTransposeMatrixf_;
-        public static Delegates.LoadTransposeMatrixd_ LoadTransposeMatrixd_;
-        public static Delegates.MultTransposeMatrixf_ MultTransposeMatrixf_;
-        public static Delegates.MultTransposeMatrixd_ MultTransposeMatrixd_;
-        public static Delegates.SampleCoverage SampleCoverage;
-        public static Delegates.CompressedTexImage3D_ CompressedTexImage3D_;
-        public static Delegates.CompressedTexImage2D_ CompressedTexImage2D_;
-        public static Delegates.CompressedTexImage1D_ CompressedTexImage1D_;
-        public static Delegates.CompressedTexSubImage3D_ CompressedTexSubImage3D_;
-        public static Delegates.CompressedTexSubImage2D_ CompressedTexSubImage2D_;
-        public static Delegates.CompressedTexSubImage1D_ CompressedTexSubImage1D_;
-        public static Delegates.GetCompressedTexImage_ GetCompressedTexImage_;
-        public static Delegates.BlendFuncSeparate BlendFuncSeparate;
-        public static Delegates.FogCoordf FogCoordf;
-        public static Delegates.FogCoordfv_ FogCoordfv_;
-        public static Delegates.FogCoordd FogCoordd;
-        public static Delegates.FogCoorddv_ FogCoorddv_;
-        public static Delegates.FogCoordPointer_ FogCoordPointer_;
-        public static Delegates.MultiDrawArrays_ MultiDrawArrays_;
-        public static Delegates.MultiDrawElements_ MultiDrawElements_;
-        public static Delegates.PointParameterf PointParameterf;
-        public static Delegates.PointParameterfv_ PointParameterfv_;
-        public static Delegates.PointParameteri PointParameteri;
-        public static Delegates.PointParameteriv_ PointParameteriv_;
-        public static Delegates.SecondaryColor3b SecondaryColor3b;
-        public static Delegates.SecondaryColor3bv_ SecondaryColor3bv_;
-        public static Delegates.SecondaryColor3d SecondaryColor3d;
-        public static Delegates.SecondaryColor3dv_ SecondaryColor3dv_;
-        public static Delegates.SecondaryColor3f SecondaryColor3f;
-        public static Delegates.SecondaryColor3fv_ SecondaryColor3fv_;
-        public static Delegates.SecondaryColor3i SecondaryColor3i;
-        public static Delegates.SecondaryColor3iv_ SecondaryColor3iv_;
-        public static Delegates.SecondaryColor3s SecondaryColor3s;
-        public static Delegates.SecondaryColor3sv_ SecondaryColor3sv_;
-        public static Delegates.SecondaryColor3ub SecondaryColor3ub;
-        public static Delegates.SecondaryColor3ubv_ SecondaryColor3ubv_;
-        public static Delegates.SecondaryColor3ui SecondaryColor3ui;
-        public static Delegates.SecondaryColor3uiv_ SecondaryColor3uiv_;
-        public static Delegates.SecondaryColor3us SecondaryColor3us;
-        public static Delegates.SecondaryColor3usv_ SecondaryColor3usv_;
-        public static Delegates.SecondaryColorPointer_ SecondaryColorPointer_;
-        public static Delegates.WindowPos2d WindowPos2d;
-        public static Delegates.WindowPos2dv_ WindowPos2dv_;
-        public static Delegates.WindowPos2f WindowPos2f;
-        public static Delegates.WindowPos2fv_ WindowPos2fv_;
-        public static Delegates.WindowPos2i WindowPos2i;
-        public static Delegates.WindowPos2iv_ WindowPos2iv_;
-        public static Delegates.WindowPos2s WindowPos2s;
-        public static Delegates.WindowPos2sv_ WindowPos2sv_;
-        public static Delegates.WindowPos3d WindowPos3d;
-        public static Delegates.WindowPos3dv_ WindowPos3dv_;
-        public static Delegates.WindowPos3f WindowPos3f;
-        public static Delegates.WindowPos3fv_ WindowPos3fv_;
-        public static Delegates.WindowPos3i WindowPos3i;
-        public static Delegates.WindowPos3iv_ WindowPos3iv_;
-        public static Delegates.WindowPos3s WindowPos3s;
-        public static Delegates.WindowPos3sv_ WindowPos3sv_;
-        public static Delegates.GenQueries_ GenQueries_;
-        public static Delegates.DeleteQueries_ DeleteQueries_;
-        public static Delegates.IsQuery IsQuery;
-        public static Delegates.BeginQuery BeginQuery;
-        public static Delegates.EndQuery EndQuery;
-        public static Delegates.GetQueryiv_ GetQueryiv_;
-        public static Delegates.GetQueryObjectiv_ GetQueryObjectiv_;
-        public static Delegates.GetQueryObjectuiv_ GetQueryObjectuiv_;
-        public static Delegates.BindBuffer BindBuffer;
-        public static Delegates.DeleteBuffers_ DeleteBuffers_;
-        public static Delegates.GenBuffers_ GenBuffers_;
-        public static Delegates.IsBuffer IsBuffer;
-        public static Delegates.BufferData_ BufferData_;
-        public static Delegates.BufferSubData_ BufferSubData_;
-        public static Delegates.GetBufferSubData_ GetBufferSubData_;
-        public static Delegates.MapBuffer MapBuffer;
-        public static Delegates.UnmapBuffer UnmapBuffer;
-        public static Delegates.GetBufferParameteriv_ GetBufferParameteriv_;
-        public static Delegates.GetBufferPointerv_ GetBufferPointerv_;
-        public static Delegates.BlendEquationSeparate BlendEquationSeparate;
-        public static Delegates.DrawBuffers_ DrawBuffers_;
-        public static Delegates.StencilOpSeparate StencilOpSeparate;
-        public static Delegates.StencilFuncSeparate StencilFuncSeparate;
-        public static Delegates.StencilMaskSeparate StencilMaskSeparate;
-        public static Delegates.AttachShader AttachShader;
-        public static Delegates.BindAttribLocation BindAttribLocation;
-        public static Delegates.CompileShader CompileShader;
-        public static Delegates.CreateProgram CreateProgram;
-        public static Delegates.CreateShader CreateShader;
-        public static Delegates.DeleteProgram DeleteProgram;
-        public static Delegates.DeleteShader DeleteShader;
-        public static Delegates.DetachShader DetachShader;
-        public static Delegates.DisableVertexAttribArray DisableVertexAttribArray;
-        public static Delegates.EnableVertexAttribArray EnableVertexAttribArray;
-        public static Delegates.GetActiveAttrib_ GetActiveAttrib_;
-        public static Delegates.GetActiveUniform_ GetActiveUniform_;
-        public static Delegates.GetAttachedShaders_ GetAttachedShaders_;
-        public static Delegates.GetAttribLocation GetAttribLocation;
-        public static Delegates.GetProgramiv_ GetProgramiv_;
-        public static Delegates.GetProgramInfoLog_ GetProgramInfoLog_;
-        public static Delegates.GetShaderiv_ GetShaderiv_;
-        public static Delegates.GetShaderInfoLog_ GetShaderInfoLog_;
-        public static Delegates.GetShaderSource_ GetShaderSource_;
-        public static Delegates.GetUniformLocation GetUniformLocation;
-        public static Delegates.GetUniformfv_ GetUniformfv_;
-        public static Delegates.GetUniformiv_ GetUniformiv_;
-        public static Delegates.GetVertexAttribdv_ GetVertexAttribdv_;
-        public static Delegates.GetVertexAttribfv_ GetVertexAttribfv_;
-        public static Delegates.GetVertexAttribiv_ GetVertexAttribiv_;
-        public static Delegates.GetVertexAttribPointerv_ GetVertexAttribPointerv_;
-        public static Delegates.IsProgram IsProgram;
-        public static Delegates.IsShader IsShader;
-        public static Delegates.LinkProgram LinkProgram;
-        public static Delegates.ShaderSource_ ShaderSource_;
-        public static Delegates.UseProgram UseProgram;
-        public static Delegates.Uniform1f Uniform1f;
-        public static Delegates.Uniform2f Uniform2f;
-        public static Delegates.Uniform3f Uniform3f;
-        public static Delegates.Uniform4f Uniform4f;
-        public static Delegates.Uniform1i Uniform1i;
-        public static Delegates.Uniform2i Uniform2i;
-        public static Delegates.Uniform3i Uniform3i;
-        public static Delegates.Uniform4i Uniform4i;
-        public static Delegates.Uniform1fv_ Uniform1fv_;
-        public static Delegates.Uniform2fv_ Uniform2fv_;
-        public static Delegates.Uniform3fv_ Uniform3fv_;
-        public static Delegates.Uniform4fv_ Uniform4fv_;
-        public static Delegates.Uniform1iv_ Uniform1iv_;
-        public static Delegates.Uniform2iv_ Uniform2iv_;
-        public static Delegates.Uniform3iv_ Uniform3iv_;
-        public static Delegates.Uniform4iv_ Uniform4iv_;
-        public static Delegates.UniformMatrix2fv_ UniformMatrix2fv_;
-        public static Delegates.UniformMatrix3fv_ UniformMatrix3fv_;
-        public static Delegates.UniformMatrix4fv_ UniformMatrix4fv_;
-        public static Delegates.ValidateProgram ValidateProgram;
-        public static Delegates.VertexAttrib1d VertexAttrib1d;
-        public static Delegates.VertexAttrib1dv_ VertexAttrib1dv_;
-        public static Delegates.VertexAttrib1f VertexAttrib1f;
-        public static Delegates.VertexAttrib1fv_ VertexAttrib1fv_;
-        public static Delegates.VertexAttrib1s VertexAttrib1s;
-        public static Delegates.VertexAttrib1sv_ VertexAttrib1sv_;
-        public static Delegates.VertexAttrib2d VertexAttrib2d;
-        public static Delegates.VertexAttrib2dv_ VertexAttrib2dv_;
-        public static Delegates.VertexAttrib2f VertexAttrib2f;
-        public static Delegates.VertexAttrib2fv_ VertexAttrib2fv_;
-        public static Delegates.VertexAttrib2s VertexAttrib2s;
-        public static Delegates.VertexAttrib2sv_ VertexAttrib2sv_;
-        public static Delegates.VertexAttrib3d VertexAttrib3d;
-        public static Delegates.VertexAttrib3dv_ VertexAttrib3dv_;
-        public static Delegates.VertexAttrib3f VertexAttrib3f;
-        public static Delegates.VertexAttrib3fv_ VertexAttrib3fv_;
-        public static Delegates.VertexAttrib3s VertexAttrib3s;
-        public static Delegates.VertexAttrib3sv_ VertexAttrib3sv_;
-        public static Delegates.VertexAttrib4Nbv_ VertexAttrib4Nbv_;
-        public static Delegates.VertexAttrib4Niv_ VertexAttrib4Niv_;
-        public static Delegates.VertexAttrib4Nsv_ VertexAttrib4Nsv_;
-        public static Delegates.VertexAttrib4Nub VertexAttrib4Nub;
-        public static Delegates.VertexAttrib4Nubv_ VertexAttrib4Nubv_;
-        public static Delegates.VertexAttrib4Nuiv_ VertexAttrib4Nuiv_;
-        public static Delegates.VertexAttrib4Nusv_ VertexAttrib4Nusv_;
-        public static Delegates.VertexAttrib4bv_ VertexAttrib4bv_;
-        public static Delegates.VertexAttrib4d VertexAttrib4d;
-        public static Delegates.VertexAttrib4dv_ VertexAttrib4dv_;
-        public static Delegates.VertexAttrib4f VertexAttrib4f;
-        public static Delegates.VertexAttrib4fv_ VertexAttrib4fv_;
-        public static Delegates.VertexAttrib4iv_ VertexAttrib4iv_;
-        public static Delegates.VertexAttrib4s VertexAttrib4s;
-        public static Delegates.VertexAttrib4sv_ VertexAttrib4sv_;
-        public static Delegates.VertexAttrib4ubv_ VertexAttrib4ubv_;
-        public static Delegates.VertexAttrib4uiv_ VertexAttrib4uiv_;
-        public static Delegates.VertexAttrib4usv_ VertexAttrib4usv_;
-        public static Delegates.VertexAttribPointer_ VertexAttribPointer_;
-        public static Delegates.UniformMatrix2x3fv_ UniformMatrix2x3fv_;
-        public static Delegates.UniformMatrix3x2fv_ UniformMatrix3x2fv_;
-        public static Delegates.UniformMatrix2x4fv_ UniformMatrix2x4fv_;
-        public static Delegates.UniformMatrix4x2fv_ UniformMatrix4x2fv_;
-        public static Delegates.UniformMatrix3x4fv_ UniformMatrix3x4fv_;
-        public static Delegates.UniformMatrix4x3fv_ UniformMatrix4x3fv_;
-        public static Delegates.ActiveTextureARB ActiveTextureARB;
-        public static Delegates.ClientActiveTextureARB ClientActiveTextureARB;
-        public static Delegates.MultiTexCoord1dARB MultiTexCoord1dARB;
-        public static Delegates.MultiTexCoord1dvARB_ MultiTexCoord1dvARB_;
-        public static Delegates.MultiTexCoord1fARB MultiTexCoord1fARB;
-        public static Delegates.MultiTexCoord1fvARB_ MultiTexCoord1fvARB_;
-        public static Delegates.MultiTexCoord1iARB MultiTexCoord1iARB;
-        public static Delegates.MultiTexCoord1ivARB_ MultiTexCoord1ivARB_;
-        public static Delegates.MultiTexCoord1sARB MultiTexCoord1sARB;
-        public static Delegates.MultiTexCoord1svARB_ MultiTexCoord1svARB_;
-        public static Delegates.MultiTexCoord2dARB MultiTexCoord2dARB;
-        public static Delegates.MultiTexCoord2dvARB_ MultiTexCoord2dvARB_;
-        public static Delegates.MultiTexCoord2fARB MultiTexCoord2fARB;
-        public static Delegates.MultiTexCoord2fvARB_ MultiTexCoord2fvARB_;
-        public static Delegates.MultiTexCoord2iARB MultiTexCoord2iARB;
-        public static Delegates.MultiTexCoord2ivARB_ MultiTexCoord2ivARB_;
-        public static Delegates.MultiTexCoord2sARB MultiTexCoord2sARB;
-        public static Delegates.MultiTexCoord2svARB_ MultiTexCoord2svARB_;
-        public static Delegates.MultiTexCoord3dARB MultiTexCoord3dARB;
-        public static Delegates.MultiTexCoord3dvARB_ MultiTexCoord3dvARB_;
-        public static Delegates.MultiTexCoord3fARB MultiTexCoord3fARB;
-        public static Delegates.MultiTexCoord3fvARB_ MultiTexCoord3fvARB_;
-        public static Delegates.MultiTexCoord3iARB MultiTexCoord3iARB;
-        public static Delegates.MultiTexCoord3ivARB_ MultiTexCoord3ivARB_;
-        public static Delegates.MultiTexCoord3sARB MultiTexCoord3sARB;
-        public static Delegates.MultiTexCoord3svARB_ MultiTexCoord3svARB_;
-        public static Delegates.MultiTexCoord4dARB MultiTexCoord4dARB;
-        public static Delegates.MultiTexCoord4dvARB_ MultiTexCoord4dvARB_;
-        public static Delegates.MultiTexCoord4fARB MultiTexCoord4fARB;
-        public static Delegates.MultiTexCoord4fvARB_ MultiTexCoord4fvARB_;
-        public static Delegates.MultiTexCoord4iARB MultiTexCoord4iARB;
-        public static Delegates.MultiTexCoord4ivARB_ MultiTexCoord4ivARB_;
-        public static Delegates.MultiTexCoord4sARB MultiTexCoord4sARB;
-        public static Delegates.MultiTexCoord4svARB_ MultiTexCoord4svARB_;
-        public static Delegates.LoadTransposeMatrixfARB_ LoadTransposeMatrixfARB_;
-        public static Delegates.LoadTransposeMatrixdARB_ LoadTransposeMatrixdARB_;
-        public static Delegates.MultTransposeMatrixfARB_ MultTransposeMatrixfARB_;
-        public static Delegates.MultTransposeMatrixdARB_ MultTransposeMatrixdARB_;
-        public static Delegates.SampleCoverageARB SampleCoverageARB;
-        public static Delegates.CompressedTexImage3DARB_ CompressedTexImage3DARB_;
-        public static Delegates.CompressedTexImage2DARB_ CompressedTexImage2DARB_;
-        public static Delegates.CompressedTexImage1DARB_ CompressedTexImage1DARB_;
-        public static Delegates.CompressedTexSubImage3DARB_ CompressedTexSubImage3DARB_;
-        public static Delegates.CompressedTexSubImage2DARB_ CompressedTexSubImage2DARB_;
-        public static Delegates.CompressedTexSubImage1DARB_ CompressedTexSubImage1DARB_;
-        public static Delegates.GetCompressedTexImageARB_ GetCompressedTexImageARB_;
-        public static Delegates.PointParameterfARB PointParameterfARB;
-        public static Delegates.PointParameterfvARB_ PointParameterfvARB_;
-        public static Delegates.WeightbvARB_ WeightbvARB_;
-        public static Delegates.WeightsvARB_ WeightsvARB_;
-        public static Delegates.WeightivARB_ WeightivARB_;
-        public static Delegates.WeightfvARB_ WeightfvARB_;
-        public static Delegates.WeightdvARB_ WeightdvARB_;
-        public static Delegates.WeightubvARB_ WeightubvARB_;
-        public static Delegates.WeightusvARB_ WeightusvARB_;
-        public static Delegates.WeightuivARB_ WeightuivARB_;
-        public static Delegates.WeightPointerARB_ WeightPointerARB_;
-        public static Delegates.VertexBlendARB VertexBlendARB;
-        public static Delegates.CurrentPaletteMatrixARB CurrentPaletteMatrixARB;
-        public static Delegates.MatrixIndexubvARB_ MatrixIndexubvARB_;
-        public static Delegates.MatrixIndexusvARB_ MatrixIndexusvARB_;
-        public static Delegates.MatrixIndexuivARB_ MatrixIndexuivARB_;
-        public static Delegates.MatrixIndexPointerARB_ MatrixIndexPointerARB_;
-        public static Delegates.WindowPos2dARB WindowPos2dARB;
-        public static Delegates.WindowPos2dvARB_ WindowPos2dvARB_;
-        public static Delegates.WindowPos2fARB WindowPos2fARB;
-        public static Delegates.WindowPos2fvARB_ WindowPos2fvARB_;
-        public static Delegates.WindowPos2iARB WindowPos2iARB;
-        public static Delegates.WindowPos2ivARB_ WindowPos2ivARB_;
-        public static Delegates.WindowPos2sARB WindowPos2sARB;
-        public static Delegates.WindowPos2svARB_ WindowPos2svARB_;
-        public static Delegates.WindowPos3dARB WindowPos3dARB;
-        public static Delegates.WindowPos3dvARB_ WindowPos3dvARB_;
-        public static Delegates.WindowPos3fARB WindowPos3fARB;
-        public static Delegates.WindowPos3fvARB_ WindowPos3fvARB_;
-        public static Delegates.WindowPos3iARB WindowPos3iARB;
-        public static Delegates.WindowPos3ivARB_ WindowPos3ivARB_;
-        public static Delegates.WindowPos3sARB WindowPos3sARB;
-        public static Delegates.WindowPos3svARB_ WindowPos3svARB_;
-        public static Delegates.VertexAttrib1dARB VertexAttrib1dARB;
-        public static Delegates.VertexAttrib1dvARB_ VertexAttrib1dvARB_;
-        public static Delegates.VertexAttrib1fARB VertexAttrib1fARB;
-        public static Delegates.VertexAttrib1fvARB_ VertexAttrib1fvARB_;
-        public static Delegates.VertexAttrib1sARB VertexAttrib1sARB;
-        public static Delegates.VertexAttrib1svARB_ VertexAttrib1svARB_;
-        public static Delegates.VertexAttrib2dARB VertexAttrib2dARB;
-        public static Delegates.VertexAttrib2dvARB_ VertexAttrib2dvARB_;
-        public static Delegates.VertexAttrib2fARB VertexAttrib2fARB;
-        public static Delegates.VertexAttrib2fvARB_ VertexAttrib2fvARB_;
-        public static Delegates.VertexAttrib2sARB VertexAttrib2sARB;
-        public static Delegates.VertexAttrib2svARB_ VertexAttrib2svARB_;
-        public static Delegates.VertexAttrib3dARB VertexAttrib3dARB;
-        public static Delegates.VertexAttrib3dvARB_ VertexAttrib3dvARB_;
-        public static Delegates.VertexAttrib3fARB VertexAttrib3fARB;
-        public static Delegates.VertexAttrib3fvARB_ VertexAttrib3fvARB_;
-        public static Delegates.VertexAttrib3sARB VertexAttrib3sARB;
-        public static Delegates.VertexAttrib3svARB_ VertexAttrib3svARB_;
-        public static Delegates.VertexAttrib4NbvARB_ VertexAttrib4NbvARB_;
-        public static Delegates.VertexAttrib4NivARB_ VertexAttrib4NivARB_;
-        public static Delegates.VertexAttrib4NsvARB_ VertexAttrib4NsvARB_;
-        public static Delegates.VertexAttrib4NubARB VertexAttrib4NubARB;
-        public static Delegates.VertexAttrib4NubvARB_ VertexAttrib4NubvARB_;
-        public static Delegates.VertexAttrib4NuivARB_ VertexAttrib4NuivARB_;
-        public static Delegates.VertexAttrib4NusvARB_ VertexAttrib4NusvARB_;
-        public static Delegates.VertexAttrib4bvARB_ VertexAttrib4bvARB_;
-        public static Delegates.VertexAttrib4dARB VertexAttrib4dARB;
-        public static Delegates.VertexAttrib4dvARB_ VertexAttrib4dvARB_;
-        public static Delegates.VertexAttrib4fARB VertexAttrib4fARB;
-        public static Delegates.VertexAttrib4fvARB_ VertexAttrib4fvARB_;
-        public static Delegates.VertexAttrib4ivARB_ VertexAttrib4ivARB_;
-        public static Delegates.VertexAttrib4sARB VertexAttrib4sARB;
-        public static Delegates.VertexAttrib4svARB_ VertexAttrib4svARB_;
-        public static Delegates.VertexAttrib4ubvARB_ VertexAttrib4ubvARB_;
-        public static Delegates.VertexAttrib4uivARB_ VertexAttrib4uivARB_;
-        public static Delegates.VertexAttrib4usvARB_ VertexAttrib4usvARB_;
-        public static Delegates.VertexAttribPointerARB_ VertexAttribPointerARB_;
-        public static Delegates.EnableVertexAttribArrayARB EnableVertexAttribArrayARB;
-        public static Delegates.DisableVertexAttribArrayARB DisableVertexAttribArrayARB;
-        public static Delegates.ProgramStringARB_ ProgramStringARB_;
-        public static Delegates.BindProgramARB BindProgramARB;
-        public static Delegates.DeleteProgramsARB_ DeleteProgramsARB_;
-        public static Delegates.GenProgramsARB_ GenProgramsARB_;
-        public static Delegates.ProgramEnvParameter4dARB ProgramEnvParameter4dARB;
-        public static Delegates.ProgramEnvParameter4dvARB_ ProgramEnvParameter4dvARB_;
-        public static Delegates.ProgramEnvParameter4fARB ProgramEnvParameter4fARB;
-        public static Delegates.ProgramEnvParameter4fvARB_ ProgramEnvParameter4fvARB_;
-        public static Delegates.ProgramLocalParameter4dARB ProgramLocalParameter4dARB;
-        public static Delegates.ProgramLocalParameter4dvARB_ ProgramLocalParameter4dvARB_;
-        public static Delegates.ProgramLocalParameter4fARB ProgramLocalParameter4fARB;
-        public static Delegates.ProgramLocalParameter4fvARB_ ProgramLocalParameter4fvARB_;
-        public static Delegates.GetProgramEnvParameterdvARB_ GetProgramEnvParameterdvARB_;
-        public static Delegates.GetProgramEnvParameterfvARB_ GetProgramEnvParameterfvARB_;
-        public static Delegates.GetProgramLocalParameterdvARB_ GetProgramLocalParameterdvARB_;
-        public static Delegates.GetProgramLocalParameterfvARB_ GetProgramLocalParameterfvARB_;
-        public static Delegates.GetProgramivARB_ GetProgramivARB_;
-        public static Delegates.GetProgramStringARB_ GetProgramStringARB_;
-        public static Delegates.GetVertexAttribdvARB_ GetVertexAttribdvARB_;
-        public static Delegates.GetVertexAttribfvARB_ GetVertexAttribfvARB_;
-        public static Delegates.GetVertexAttribivARB_ GetVertexAttribivARB_;
-        public static Delegates.GetVertexAttribPointervARB_ GetVertexAttribPointervARB_;
-        public static Delegates.IsProgramARB IsProgramARB;
-        public static Delegates.BindBufferARB BindBufferARB;
-        public static Delegates.DeleteBuffersARB_ DeleteBuffersARB_;
-        public static Delegates.GenBuffersARB_ GenBuffersARB_;
-        public static Delegates.IsBufferARB IsBufferARB;
-        public static Delegates.BufferDataARB_ BufferDataARB_;
-        public static Delegates.BufferSubDataARB_ BufferSubDataARB_;
-        public static Delegates.GetBufferSubDataARB_ GetBufferSubDataARB_;
-        public static Delegates.MapBufferARB MapBufferARB;
-        public static Delegates.UnmapBufferARB UnmapBufferARB;
-        public static Delegates.GetBufferParameterivARB_ GetBufferParameterivARB_;
-        public static Delegates.GetBufferPointervARB_ GetBufferPointervARB_;
-        public static Delegates.GenQueriesARB_ GenQueriesARB_;
-        public static Delegates.DeleteQueriesARB_ DeleteQueriesARB_;
-        public static Delegates.IsQueryARB IsQueryARB;
-        public static Delegates.BeginQueryARB BeginQueryARB;
-        public static Delegates.EndQueryARB EndQueryARB;
-        public static Delegates.GetQueryivARB_ GetQueryivARB_;
-        public static Delegates.GetQueryObjectivARB_ GetQueryObjectivARB_;
-        public static Delegates.GetQueryObjectuivARB_ GetQueryObjectuivARB_;
-        public static Delegates.DeleteObjectARB DeleteObjectARB;
-        public static Delegates.GetHandleARB GetHandleARB;
-        public static Delegates.DetachObjectARB DetachObjectARB;
-        public static Delegates.CreateShaderObjectARB CreateShaderObjectARB;
-        public static Delegates.ShaderSourceARB_ ShaderSourceARB_;
-        public static Delegates.CompileShaderARB CompileShaderARB;
-        public static Delegates.CreateProgramObjectARB CreateProgramObjectARB;
-        public static Delegates.AttachObjectARB AttachObjectARB;
-        public static Delegates.LinkProgramARB LinkProgramARB;
-        public static Delegates.UseProgramObjectARB UseProgramObjectARB;
-        public static Delegates.ValidateProgramARB ValidateProgramARB;
-        public static Delegates.Uniform1fARB Uniform1fARB;
-        public static Delegates.Uniform2fARB Uniform2fARB;
-        public static Delegates.Uniform3fARB Uniform3fARB;
-        public static Delegates.Uniform4fARB Uniform4fARB;
-        public static Delegates.Uniform1iARB Uniform1iARB;
-        public static Delegates.Uniform2iARB Uniform2iARB;
-        public static Delegates.Uniform3iARB Uniform3iARB;
-        public static Delegates.Uniform4iARB Uniform4iARB;
-        public static Delegates.Uniform1fvARB_ Uniform1fvARB_;
-        public static Delegates.Uniform2fvARB_ Uniform2fvARB_;
-        public static Delegates.Uniform3fvARB_ Uniform3fvARB_;
-        public static Delegates.Uniform4fvARB_ Uniform4fvARB_;
-        public static Delegates.Uniform1ivARB_ Uniform1ivARB_;
-        public static Delegates.Uniform2ivARB_ Uniform2ivARB_;
-        public static Delegates.Uniform3ivARB_ Uniform3ivARB_;
-        public static Delegates.Uniform4ivARB_ Uniform4ivARB_;
-        public static Delegates.UniformMatrix2fvARB_ UniformMatrix2fvARB_;
-        public static Delegates.UniformMatrix3fvARB_ UniformMatrix3fvARB_;
-        public static Delegates.UniformMatrix4fvARB_ UniformMatrix4fvARB_;
-        public static Delegates.GetObjectParameterfvARB_ GetObjectParameterfvARB_;
-        public static Delegates.GetObjectParameterivARB_ GetObjectParameterivARB_;
-        public static Delegates.GetInfoLogARB_ GetInfoLogARB_;
-        public static Delegates.GetAttachedObjectsARB_ GetAttachedObjectsARB_;
-        public static Delegates.GetUniformLocationARB GetUniformLocationARB;
-        public static Delegates.GetActiveUniformARB_ GetActiveUniformARB_;
-        public static Delegates.GetUniformfvARB_ GetUniformfvARB_;
-        public static Delegates.GetUniformivARB_ GetUniformivARB_;
-        public static Delegates.GetShaderSourceARB_ GetShaderSourceARB_;
-        public static Delegates.BindAttribLocationARB BindAttribLocationARB;
-        public static Delegates.GetActiveAttribARB_ GetActiveAttribARB_;
-        public static Delegates.GetAttribLocationARB GetAttribLocationARB;
-        public static Delegates.DrawBuffersARB_ DrawBuffersARB_;
-        public static Delegates.ClampColorARB ClampColorARB;
-        public static Delegates.BlendColorEXT BlendColorEXT;
-        public static Delegates.PolygonOffsetEXT PolygonOffsetEXT;
-        public static Delegates.TexImage3DEXT_ TexImage3DEXT_;
-        public static Delegates.TexSubImage3DEXT_ TexSubImage3DEXT_;
-        public static Delegates.GetTexFilterFuncSGIS_ GetTexFilterFuncSGIS_;
-        public static Delegates.TexFilterFuncSGIS_ TexFilterFuncSGIS_;
-        public static Delegates.TexSubImage1DEXT_ TexSubImage1DEXT_;
-        public static Delegates.TexSubImage2DEXT_ TexSubImage2DEXT_;
-        public static Delegates.CopyTexImage1DEXT CopyTexImage1DEXT;
-        public static Delegates.CopyTexImage2DEXT CopyTexImage2DEXT;
-        public static Delegates.CopyTexSubImage1DEXT CopyTexSubImage1DEXT;
-        public static Delegates.CopyTexSubImage2DEXT CopyTexSubImage2DEXT;
-        public static Delegates.CopyTexSubImage3DEXT CopyTexSubImage3DEXT;
-        public static Delegates.GetHistogramEXT_ GetHistogramEXT_;
-        public static Delegates.GetHistogramParameterfvEXT_ GetHistogramParameterfvEXT_;
-        public static Delegates.GetHistogramParameterivEXT_ GetHistogramParameterivEXT_;
-        public static Delegates.GetMinmaxEXT_ GetMinmaxEXT_;
-        public static Delegates.GetMinmaxParameterfvEXT_ GetMinmaxParameterfvEXT_;
-        public static Delegates.GetMinmaxParameterivEXT_ GetMinmaxParameterivEXT_;
-        public static Delegates.HistogramEXT HistogramEXT;
-        public static Delegates.MinmaxEXT MinmaxEXT;
-        public static Delegates.ResetHistogramEXT ResetHistogramEXT;
-        public static Delegates.ResetMinmaxEXT ResetMinmaxEXT;
-        public static Delegates.ConvolutionFilter1DEXT_ ConvolutionFilter1DEXT_;
-        public static Delegates.ConvolutionFilter2DEXT_ ConvolutionFilter2DEXT_;
-        public static Delegates.ConvolutionParameterfEXT ConvolutionParameterfEXT;
-        public static Delegates.ConvolutionParameterfvEXT_ ConvolutionParameterfvEXT_;
-        public static Delegates.ConvolutionParameteriEXT ConvolutionParameteriEXT;
-        public static Delegates.ConvolutionParameterivEXT_ ConvolutionParameterivEXT_;
-        public static Delegates.CopyConvolutionFilter1DEXT CopyConvolutionFilter1DEXT;
-        public static Delegates.CopyConvolutionFilter2DEXT CopyConvolutionFilter2DEXT;
-        public static Delegates.GetConvolutionFilterEXT_ GetConvolutionFilterEXT_;
-        public static Delegates.GetConvolutionParameterfvEXT_ GetConvolutionParameterfvEXT_;
-        public static Delegates.GetConvolutionParameterivEXT_ GetConvolutionParameterivEXT_;
-        public static Delegates.GetSeparableFilterEXT_ GetSeparableFilterEXT_;
-        public static Delegates.SeparableFilter2DEXT_ SeparableFilter2DEXT_;
-        public static Delegates.ColorTableSGI_ ColorTableSGI_;
-        public static Delegates.ColorTableParameterfvSGI_ ColorTableParameterfvSGI_;
-        public static Delegates.ColorTableParameterivSGI_ ColorTableParameterivSGI_;
-        public static Delegates.CopyColorTableSGI CopyColorTableSGI;
-        public static Delegates.GetColorTableSGI_ GetColorTableSGI_;
-        public static Delegates.GetColorTableParameterfvSGI_ GetColorTableParameterfvSGI_;
-        public static Delegates.GetColorTableParameterivSGI_ GetColorTableParameterivSGI_;
-        public static Delegates.PixelTexGenSGIX PixelTexGenSGIX;
-        public static Delegates.PixelTexGenParameteriSGIS PixelTexGenParameteriSGIS;
-        public static Delegates.PixelTexGenParameterivSGIS_ PixelTexGenParameterivSGIS_;
-        public static Delegates.PixelTexGenParameterfSGIS PixelTexGenParameterfSGIS;
-        public static Delegates.PixelTexGenParameterfvSGIS_ PixelTexGenParameterfvSGIS_;
-        public static Delegates.GetPixelTexGenParameterivSGIS_ GetPixelTexGenParameterivSGIS_;
-        public static Delegates.GetPixelTexGenParameterfvSGIS_ GetPixelTexGenParameterfvSGIS_;
-        public static Delegates.TexImage4DSGIS_ TexImage4DSGIS_;
-        public static Delegates.TexSubImage4DSGIS_ TexSubImage4DSGIS_;
-        public static Delegates.AreTexturesResidentEXT_ AreTexturesResidentEXT_;
-        public static Delegates.BindTextureEXT BindTextureEXT;
-        public static Delegates.DeleteTexturesEXT_ DeleteTexturesEXT_;
-        public static Delegates.GenTexturesEXT_ GenTexturesEXT_;
-        public static Delegates.IsTextureEXT IsTextureEXT;
-        public static Delegates.PrioritizeTexturesEXT_ PrioritizeTexturesEXT_;
-        public static Delegates.DetailTexFuncSGIS_ DetailTexFuncSGIS_;
-        public static Delegates.GetDetailTexFuncSGIS_ GetDetailTexFuncSGIS_;
-        public static Delegates.SharpenTexFuncSGIS_ SharpenTexFuncSGIS_;
-        public static Delegates.GetSharpenTexFuncSGIS_ GetSharpenTexFuncSGIS_;
-        public static Delegates.SampleMaskSGIS SampleMaskSGIS;
-        public static Delegates.SamplePatternSGIS SamplePatternSGIS;
-        public static Delegates.ArrayElementEXT ArrayElementEXT;
-        public static Delegates.ColorPointerEXT_ ColorPointerEXT_;
-        public static Delegates.DrawArraysEXT DrawArraysEXT;
-        public static Delegates.EdgeFlagPointerEXT_ EdgeFlagPointerEXT_;
-        public static Delegates.GetPointervEXT_ GetPointervEXT_;
-        public static Delegates.IndexPointerEXT_ IndexPointerEXT_;
-        public static Delegates.NormalPointerEXT_ NormalPointerEXT_;
-        public static Delegates.TexCoordPointerEXT_ TexCoordPointerEXT_;
-        public static Delegates.VertexPointerEXT_ VertexPointerEXT_;
-        public static Delegates.BlendEquationEXT BlendEquationEXT;
-        public static Delegates.SpriteParameterfSGIX SpriteParameterfSGIX;
-        public static Delegates.SpriteParameterfvSGIX_ SpriteParameterfvSGIX_;
-        public static Delegates.SpriteParameteriSGIX SpriteParameteriSGIX;
-        public static Delegates.SpriteParameterivSGIX_ SpriteParameterivSGIX_;
-        public static Delegates.PointParameterfEXT PointParameterfEXT;
-        public static Delegates.PointParameterfvEXT_ PointParameterfvEXT_;
-        public static Delegates.PointParameterfSGIS PointParameterfSGIS;
-        public static Delegates.PointParameterfvSGIS_ PointParameterfvSGIS_;
-        public static Delegates.GetInstrumentsSGIX GetInstrumentsSGIX;
-        public static Delegates.InstrumentsBufferSGIX_ InstrumentsBufferSGIX_;
-        public static Delegates.PollInstrumentsSGIX_ PollInstrumentsSGIX_;
-        public static Delegates.ReadInstrumentsSGIX ReadInstrumentsSGIX;
-        public static Delegates.StartInstrumentsSGIX StartInstrumentsSGIX;
-        public static Delegates.StopInstrumentsSGIX StopInstrumentsSGIX;
-        public static Delegates.FrameZoomSGIX FrameZoomSGIX;
-        public static Delegates.TagSampleBufferSGIX TagSampleBufferSGIX;
-        public static Delegates.DeformationMap3dSGIX_ DeformationMap3dSGIX_;
-        public static Delegates.DeformationMap3fSGIX_ DeformationMap3fSGIX_;
-        public static Delegates.DeformSGIX DeformSGIX;
-        public static Delegates.LoadIdentityDeformationMapSGIX LoadIdentityDeformationMapSGIX;
-        public static Delegates.ReferencePlaneSGIX_ ReferencePlaneSGIX_;
-        public static Delegates.FlushRasterSGIX FlushRasterSGIX;
-        public static Delegates.FogFuncSGIS_ FogFuncSGIS_;
-        public static Delegates.GetFogFuncSGIS_ GetFogFuncSGIS_;
-        public static Delegates.ImageTransformParameteriHP ImageTransformParameteriHP;
-        public static Delegates.ImageTransformParameterfHP ImageTransformParameterfHP;
-        public static Delegates.ImageTransformParameterivHP_ ImageTransformParameterivHP_;
-        public static Delegates.ImageTransformParameterfvHP_ ImageTransformParameterfvHP_;
-        public static Delegates.GetImageTransformParameterivHP_ GetImageTransformParameterivHP_;
-        public static Delegates.GetImageTransformParameterfvHP_ GetImageTransformParameterfvHP_;
-        public static Delegates.ColorSubTableEXT_ ColorSubTableEXT_;
-        public static Delegates.CopyColorSubTableEXT CopyColorSubTableEXT;
-        public static Delegates.HintPGI HintPGI;
-        public static Delegates.ColorTableEXT_ ColorTableEXT_;
-        public static Delegates.GetColorTableEXT_ GetColorTableEXT_;
-        public static Delegates.GetColorTableParameterivEXT_ GetColorTableParameterivEXT_;
-        public static Delegates.GetColorTableParameterfvEXT_ GetColorTableParameterfvEXT_;
-        public static Delegates.GetListParameterfvSGIX_ GetListParameterfvSGIX_;
-        public static Delegates.GetListParameterivSGIX_ GetListParameterivSGIX_;
-        public static Delegates.ListParameterfSGIX ListParameterfSGIX;
-        public static Delegates.ListParameterfvSGIX_ ListParameterfvSGIX_;
-        public static Delegates.ListParameteriSGIX ListParameteriSGIX;
-        public static Delegates.ListParameterivSGIX_ ListParameterivSGIX_;
-        public static Delegates.IndexMaterialEXT IndexMaterialEXT;
-        public static Delegates.IndexFuncEXT IndexFuncEXT;
-        public static Delegates.LockArraysEXT LockArraysEXT;
-        public static Delegates.UnlockArraysEXT UnlockArraysEXT;
-        public static Delegates.CullParameterdvEXT_ CullParameterdvEXT_;
-        public static Delegates.CullParameterfvEXT_ CullParameterfvEXT_;
-        public static Delegates.FragmentColorMaterialSGIX FragmentColorMaterialSGIX;
-        public static Delegates.FragmentLightfSGIX FragmentLightfSGIX;
-        public static Delegates.FragmentLightfvSGIX_ FragmentLightfvSGIX_;
-        public static Delegates.FragmentLightiSGIX FragmentLightiSGIX;
-        public static Delegates.FragmentLightivSGIX_ FragmentLightivSGIX_;
-        public static Delegates.FragmentLightModelfSGIX FragmentLightModelfSGIX;
-        public static Delegates.FragmentLightModelfvSGIX_ FragmentLightModelfvSGIX_;
-        public static Delegates.FragmentLightModeliSGIX FragmentLightModeliSGIX;
-        public static Delegates.FragmentLightModelivSGIX_ FragmentLightModelivSGIX_;
-        public static Delegates.FragmentMaterialfSGIX FragmentMaterialfSGIX;
-        public static Delegates.FragmentMaterialfvSGIX_ FragmentMaterialfvSGIX_;
-        public static Delegates.FragmentMaterialiSGIX FragmentMaterialiSGIX;
-        public static Delegates.FragmentMaterialivSGIX_ FragmentMaterialivSGIX_;
-        public static Delegates.GetFragmentLightfvSGIX_ GetFragmentLightfvSGIX_;
-        public static Delegates.GetFragmentLightivSGIX_ GetFragmentLightivSGIX_;
-        public static Delegates.GetFragmentMaterialfvSGIX_ GetFragmentMaterialfvSGIX_;
-        public static Delegates.GetFragmentMaterialivSGIX_ GetFragmentMaterialivSGIX_;
-        public static Delegates.LightEnviSGIX LightEnviSGIX;
-        public static Delegates.DrawRangeElementsEXT_ DrawRangeElementsEXT_;
-        public static Delegates.ApplyTextureEXT ApplyTextureEXT;
-        public static Delegates.TextureLightEXT TextureLightEXT;
-        public static Delegates.TextureMaterialEXT TextureMaterialEXT;
-        public static Delegates.AsyncMarkerSGIX AsyncMarkerSGIX;
-        public static Delegates.FinishAsyncSGIX_ FinishAsyncSGIX_;
-        public static Delegates.PollAsyncSGIX_ PollAsyncSGIX_;
-        public static Delegates.GenAsyncMarkersSGIX GenAsyncMarkersSGIX;
-        public static Delegates.DeleteAsyncMarkersSGIX DeleteAsyncMarkersSGIX;
-        public static Delegates.IsAsyncMarkerSGIX IsAsyncMarkerSGIX;
-        public static Delegates.VertexPointervINTEL_ VertexPointervINTEL_;
-        public static Delegates.NormalPointervINTEL_ NormalPointervINTEL_;
-        public static Delegates.ColorPointervINTEL_ ColorPointervINTEL_;
-        public static Delegates.TexCoordPointervINTEL_ TexCoordPointervINTEL_;
-        public static Delegates.PixelTransformParameteriEXT PixelTransformParameteriEXT;
-        public static Delegates.PixelTransformParameterfEXT PixelTransformParameterfEXT;
-        public static Delegates.PixelTransformParameterivEXT_ PixelTransformParameterivEXT_;
-        public static Delegates.PixelTransformParameterfvEXT_ PixelTransformParameterfvEXT_;
-        public static Delegates.SecondaryColor3bEXT SecondaryColor3bEXT;
-        public static Delegates.SecondaryColor3bvEXT_ SecondaryColor3bvEXT_;
-        public static Delegates.SecondaryColor3dEXT SecondaryColor3dEXT;
-        public static Delegates.SecondaryColor3dvEXT_ SecondaryColor3dvEXT_;
-        public static Delegates.SecondaryColor3fEXT SecondaryColor3fEXT;
-        public static Delegates.SecondaryColor3fvEXT_ SecondaryColor3fvEXT_;
-        public static Delegates.SecondaryColor3iEXT SecondaryColor3iEXT;
-        public static Delegates.SecondaryColor3ivEXT_ SecondaryColor3ivEXT_;
-        public static Delegates.SecondaryColor3sEXT SecondaryColor3sEXT;
-        public static Delegates.SecondaryColor3svEXT_ SecondaryColor3svEXT_;
-        public static Delegates.SecondaryColor3ubEXT SecondaryColor3ubEXT;
-        public static Delegates.SecondaryColor3ubvEXT_ SecondaryColor3ubvEXT_;
-        public static Delegates.SecondaryColor3uiEXT SecondaryColor3uiEXT;
-        public static Delegates.SecondaryColor3uivEXT_ SecondaryColor3uivEXT_;
-        public static Delegates.SecondaryColor3usEXT SecondaryColor3usEXT;
-        public static Delegates.SecondaryColor3usvEXT_ SecondaryColor3usvEXT_;
-        public static Delegates.SecondaryColorPointerEXT_ SecondaryColorPointerEXT_;
-        public static Delegates.TextureNormalEXT TextureNormalEXT;
-        public static Delegates.MultiDrawArraysEXT_ MultiDrawArraysEXT_;
-        public static Delegates.MultiDrawElementsEXT_ MultiDrawElementsEXT_;
-        public static Delegates.FogCoordfEXT FogCoordfEXT;
-        public static Delegates.FogCoordfvEXT_ FogCoordfvEXT_;
-        public static Delegates.FogCoorddEXT FogCoorddEXT;
-        public static Delegates.FogCoorddvEXT_ FogCoorddvEXT_;
-        public static Delegates.FogCoordPointerEXT_ FogCoordPointerEXT_;
-        public static Delegates.Tangent3bEXT Tangent3bEXT;
-        public static Delegates.Tangent3bvEXT_ Tangent3bvEXT_;
-        public static Delegates.Tangent3dEXT Tangent3dEXT;
-        public static Delegates.Tangent3dvEXT_ Tangent3dvEXT_;
-        public static Delegates.Tangent3fEXT Tangent3fEXT;
-        public static Delegates.Tangent3fvEXT_ Tangent3fvEXT_;
-        public static Delegates.Tangent3iEXT Tangent3iEXT;
-        public static Delegates.Tangent3ivEXT_ Tangent3ivEXT_;
-        public static Delegates.Tangent3sEXT Tangent3sEXT;
-        public static Delegates.Tangent3svEXT_ Tangent3svEXT_;
-        public static Delegates.Binormal3bEXT Binormal3bEXT;
-        public static Delegates.Binormal3bvEXT_ Binormal3bvEXT_;
-        public static Delegates.Binormal3dEXT Binormal3dEXT;
-        public static Delegates.Binormal3dvEXT_ Binormal3dvEXT_;
-        public static Delegates.Binormal3fEXT Binormal3fEXT;
-        public static Delegates.Binormal3fvEXT_ Binormal3fvEXT_;
-        public static Delegates.Binormal3iEXT Binormal3iEXT;
-        public static Delegates.Binormal3ivEXT_ Binormal3ivEXT_;
-        public static Delegates.Binormal3sEXT Binormal3sEXT;
-        public static Delegates.Binormal3svEXT_ Binormal3svEXT_;
-        public static Delegates.TangentPointerEXT_ TangentPointerEXT_;
-        public static Delegates.BinormalPointerEXT_ BinormalPointerEXT_;
-        public static Delegates.FinishTextureSUNX FinishTextureSUNX;
-        public static Delegates.GlobalAlphaFactorbSUN GlobalAlphaFactorbSUN;
-        public static Delegates.GlobalAlphaFactorsSUN GlobalAlphaFactorsSUN;
-        public static Delegates.GlobalAlphaFactoriSUN GlobalAlphaFactoriSUN;
-        public static Delegates.GlobalAlphaFactorfSUN GlobalAlphaFactorfSUN;
-        public static Delegates.GlobalAlphaFactordSUN GlobalAlphaFactordSUN;
-        public static Delegates.GlobalAlphaFactorubSUN GlobalAlphaFactorubSUN;
-        public static Delegates.GlobalAlphaFactorusSUN GlobalAlphaFactorusSUN;
-        public static Delegates.GlobalAlphaFactoruiSUN GlobalAlphaFactoruiSUN;
-        public static Delegates.ReplacementCodeuiSUN ReplacementCodeuiSUN;
-        public static Delegates.ReplacementCodeusSUN ReplacementCodeusSUN;
-        public static Delegates.ReplacementCodeubSUN ReplacementCodeubSUN;
-        public static Delegates.ReplacementCodeuivSUN_ ReplacementCodeuivSUN_;
-        public static Delegates.ReplacementCodeusvSUN_ ReplacementCodeusvSUN_;
-        public static Delegates.ReplacementCodeubvSUN_ ReplacementCodeubvSUN_;
-        public static Delegates.ReplacementCodePointerSUN_ ReplacementCodePointerSUN_;
-        public static Delegates.Color4ubVertex2fSUN Color4ubVertex2fSUN;
-        public static Delegates.Color4ubVertex2fvSUN_ Color4ubVertex2fvSUN_;
-        public static Delegates.Color4ubVertex3fSUN Color4ubVertex3fSUN;
-        public static Delegates.Color4ubVertex3fvSUN_ Color4ubVertex3fvSUN_;
-        public static Delegates.Color3fVertex3fSUN Color3fVertex3fSUN;
-        public static Delegates.Color3fVertex3fvSUN_ Color3fVertex3fvSUN_;
-        public static Delegates.Normal3fVertex3fSUN Normal3fVertex3fSUN;
-        public static Delegates.Normal3fVertex3fvSUN_ Normal3fVertex3fvSUN_;
-        public static Delegates.Color4fNormal3fVertex3fSUN Color4fNormal3fVertex3fSUN;
-        public static Delegates.Color4fNormal3fVertex3fvSUN_ Color4fNormal3fVertex3fvSUN_;
-        public static Delegates.TexCoord2fVertex3fSUN TexCoord2fVertex3fSUN;
-        public static Delegates.TexCoord2fVertex3fvSUN_ TexCoord2fVertex3fvSUN_;
-        public static Delegates.TexCoord4fVertex4fSUN TexCoord4fVertex4fSUN;
-        public static Delegates.TexCoord4fVertex4fvSUN_ TexCoord4fVertex4fvSUN_;
-        public static Delegates.TexCoord2fColor4ubVertex3fSUN TexCoord2fColor4ubVertex3fSUN;
-        public static Delegates.TexCoord2fColor4ubVertex3fvSUN_ TexCoord2fColor4ubVertex3fvSUN_;
-        public static Delegates.TexCoord2fColor3fVertex3fSUN TexCoord2fColor3fVertex3fSUN;
-        public static Delegates.TexCoord2fColor3fVertex3fvSUN_ TexCoord2fColor3fVertex3fvSUN_;
-        public static Delegates.TexCoord2fNormal3fVertex3fSUN TexCoord2fNormal3fVertex3fSUN;
-        public static Delegates.TexCoord2fNormal3fVertex3fvSUN_ TexCoord2fNormal3fVertex3fvSUN_;
-        public static Delegates.TexCoord2fColor4fNormal3fVertex3fSUN TexCoord2fColor4fNormal3fVertex3fSUN;
-        public static Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN_ TexCoord2fColor4fNormal3fVertex3fvSUN_;
-        public static Delegates.TexCoord4fColor4fNormal3fVertex4fSUN TexCoord4fColor4fNormal3fVertex4fSUN;
-        public static Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN_ TexCoord4fColor4fNormal3fVertex4fvSUN_;
-        public static Delegates.ReplacementCodeuiVertex3fSUN ReplacementCodeuiVertex3fSUN;
-        public static Delegates.ReplacementCodeuiVertex3fvSUN_ ReplacementCodeuiVertex3fvSUN_;
-        public static Delegates.ReplacementCodeuiColor4ubVertex3fSUN ReplacementCodeuiColor4ubVertex3fSUN;
-        public static Delegates.ReplacementCodeuiColor4ubVertex3fvSUN_ ReplacementCodeuiColor4ubVertex3fvSUN_;
-        public static Delegates.ReplacementCodeuiColor3fVertex3fSUN ReplacementCodeuiColor3fVertex3fSUN;
-        public static Delegates.ReplacementCodeuiColor3fVertex3fvSUN_ ReplacementCodeuiColor3fVertex3fvSUN_;
-        public static Delegates.ReplacementCodeuiNormal3fVertex3fSUN ReplacementCodeuiNormal3fVertex3fSUN;
-        public static Delegates.ReplacementCodeuiNormal3fVertex3fvSUN_ ReplacementCodeuiNormal3fVertex3fvSUN_;
-        public static Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN ReplacementCodeuiColor4fNormal3fVertex3fSUN;
-        public static Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ ReplacementCodeuiColor4fNormal3fVertex3fvSUN_;
-        public static Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN ReplacementCodeuiTexCoord2fVertex3fSUN;
-        public static Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN_ ReplacementCodeuiTexCoord2fVertex3fvSUN_;
-        public static Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN;
-        public static Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_;
-        public static Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN;
-        public static Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_;
-        public static Delegates.BlendFuncSeparateEXT BlendFuncSeparateEXT;
-        public static Delegates.BlendFuncSeparateINGR BlendFuncSeparateINGR;
-        public static Delegates.VertexWeightfEXT VertexWeightfEXT;
-        public static Delegates.VertexWeightfvEXT_ VertexWeightfvEXT_;
-        public static Delegates.VertexWeightPointerEXT_ VertexWeightPointerEXT_;
-        public static Delegates.FlushVertexArrayRangeNV FlushVertexArrayRangeNV;
-        public static Delegates.VertexArrayRangeNV_ VertexArrayRangeNV_;
-        public static Delegates.CombinerParameterfvNV_ CombinerParameterfvNV_;
-        public static Delegates.CombinerParameterfNV CombinerParameterfNV;
-        public static Delegates.CombinerParameterivNV_ CombinerParameterivNV_;
-        public static Delegates.CombinerParameteriNV CombinerParameteriNV;
-        public static Delegates.CombinerInputNV CombinerInputNV;
-        public static Delegates.CombinerOutputNV CombinerOutputNV;
-        public static Delegates.FinalCombinerInputNV FinalCombinerInputNV;
-        public static Delegates.GetCombinerInputParameterfvNV_ GetCombinerInputParameterfvNV_;
-        public static Delegates.GetCombinerInputParameterivNV_ GetCombinerInputParameterivNV_;
-        public static Delegates.GetCombinerOutputParameterfvNV_ GetCombinerOutputParameterfvNV_;
-        public static Delegates.GetCombinerOutputParameterivNV_ GetCombinerOutputParameterivNV_;
-        public static Delegates.GetFinalCombinerInputParameterfvNV_ GetFinalCombinerInputParameterfvNV_;
-        public static Delegates.GetFinalCombinerInputParameterivNV_ GetFinalCombinerInputParameterivNV_;
-        public static Delegates.ResizeBuffersMESA ResizeBuffersMESA;
-        public static Delegates.WindowPos2dMESA WindowPos2dMESA;
-        public static Delegates.WindowPos2dvMESA_ WindowPos2dvMESA_;
-        public static Delegates.WindowPos2fMESA WindowPos2fMESA;
-        public static Delegates.WindowPos2fvMESA_ WindowPos2fvMESA_;
-        public static Delegates.WindowPos2iMESA WindowPos2iMESA;
-        public static Delegates.WindowPos2ivMESA_ WindowPos2ivMESA_;
-        public static Delegates.WindowPos2sMESA WindowPos2sMESA;
-        public static Delegates.WindowPos2svMESA_ WindowPos2svMESA_;
-        public static Delegates.WindowPos3dMESA WindowPos3dMESA;
-        public static Delegates.WindowPos3dvMESA_ WindowPos3dvMESA_;
-        public static Delegates.WindowPos3fMESA WindowPos3fMESA;
-        public static Delegates.WindowPos3fvMESA_ WindowPos3fvMESA_;
-        public static Delegates.WindowPos3iMESA WindowPos3iMESA;
-        public static Delegates.WindowPos3ivMESA_ WindowPos3ivMESA_;
-        public static Delegates.WindowPos3sMESA WindowPos3sMESA;
-        public static Delegates.WindowPos3svMESA_ WindowPos3svMESA_;
-        public static Delegates.WindowPos4dMESA WindowPos4dMESA;
-        public static Delegates.WindowPos4dvMESA_ WindowPos4dvMESA_;
-        public static Delegates.WindowPos4fMESA WindowPos4fMESA;
-        public static Delegates.WindowPos4fvMESA_ WindowPos4fvMESA_;
-        public static Delegates.WindowPos4iMESA WindowPos4iMESA;
-        public static Delegates.WindowPos4ivMESA_ WindowPos4ivMESA_;
-        public static Delegates.WindowPos4sMESA WindowPos4sMESA;
-        public static Delegates.WindowPos4svMESA_ WindowPos4svMESA_;
-        public static Delegates.MultiModeDrawArraysIBM_ MultiModeDrawArraysIBM_;
-        public static Delegates.MultiModeDrawElementsIBM_ MultiModeDrawElementsIBM_;
-        public static Delegates.ColorPointerListIBM_ ColorPointerListIBM_;
-        public static Delegates.SecondaryColorPointerListIBM_ SecondaryColorPointerListIBM_;
-        public static Delegates.EdgeFlagPointerListIBM_ EdgeFlagPointerListIBM_;
-        public static Delegates.FogCoordPointerListIBM_ FogCoordPointerListIBM_;
-        public static Delegates.IndexPointerListIBM_ IndexPointerListIBM_;
-        public static Delegates.NormalPointerListIBM_ NormalPointerListIBM_;
-        public static Delegates.TexCoordPointerListIBM_ TexCoordPointerListIBM_;
-        public static Delegates.VertexPointerListIBM_ VertexPointerListIBM_;
-        public static Delegates.TbufferMask3DFX TbufferMask3DFX;
-        public static Delegates.SampleMaskEXT SampleMaskEXT;
-        public static Delegates.SamplePatternEXT SamplePatternEXT;
-        public static Delegates.TextureColorMaskSGIS TextureColorMaskSGIS;
-        public static Delegates.IglooInterfaceSGIX_ IglooInterfaceSGIX_;
-        public static Delegates.DeleteFencesNV_ DeleteFencesNV_;
-        public static Delegates.GenFencesNV_ GenFencesNV_;
-        public static Delegates.IsFenceNV IsFenceNV;
-        public static Delegates.TestFenceNV TestFenceNV;
-        public static Delegates.GetFenceivNV_ GetFenceivNV_;
-        public static Delegates.FinishFenceNV FinishFenceNV;
-        public static Delegates.SetFenceNV SetFenceNV;
-        public static Delegates.MapControlPointsNV_ MapControlPointsNV_;
-        public static Delegates.MapParameterivNV_ MapParameterivNV_;
-        public static Delegates.MapParameterfvNV_ MapParameterfvNV_;
-        public static Delegates.GetMapControlPointsNV_ GetMapControlPointsNV_;
-        public static Delegates.GetMapParameterivNV_ GetMapParameterivNV_;
-        public static Delegates.GetMapParameterfvNV_ GetMapParameterfvNV_;
-        public static Delegates.GetMapAttribParameterivNV_ GetMapAttribParameterivNV_;
-        public static Delegates.GetMapAttribParameterfvNV_ GetMapAttribParameterfvNV_;
-        public static Delegates.EvalMapsNV EvalMapsNV;
-        public static Delegates.CombinerStageParameterfvNV_ CombinerStageParameterfvNV_;
-        public static Delegates.GetCombinerStageParameterfvNV_ GetCombinerStageParameterfvNV_;
-        public static Delegates.AreProgramsResidentNV_ AreProgramsResidentNV_;
-        public static Delegates.BindProgramNV BindProgramNV;
-        public static Delegates.DeleteProgramsNV_ DeleteProgramsNV_;
-        public static Delegates.ExecuteProgramNV_ ExecuteProgramNV_;
-        public static Delegates.GenProgramsNV_ GenProgramsNV_;
-        public static Delegates.GetProgramParameterdvNV_ GetProgramParameterdvNV_;
-        public static Delegates.GetProgramParameterfvNV_ GetProgramParameterfvNV_;
-        public static Delegates.GetProgramivNV_ GetProgramivNV_;
-        public static Delegates.GetProgramStringNV_ GetProgramStringNV_;
-        public static Delegates.GetTrackMatrixivNV_ GetTrackMatrixivNV_;
-        public static Delegates.GetVertexAttribdvNV_ GetVertexAttribdvNV_;
-        public static Delegates.GetVertexAttribfvNV_ GetVertexAttribfvNV_;
-        public static Delegates.GetVertexAttribivNV_ GetVertexAttribivNV_;
-        public static Delegates.GetVertexAttribPointervNV_ GetVertexAttribPointervNV_;
-        public static Delegates.IsProgramNV IsProgramNV;
-        public static Delegates.LoadProgramNV_ LoadProgramNV_;
-        public static Delegates.ProgramParameter4dNV ProgramParameter4dNV;
-        public static Delegates.ProgramParameter4dvNV_ ProgramParameter4dvNV_;
-        public static Delegates.ProgramParameter4fNV ProgramParameter4fNV;
-        public static Delegates.ProgramParameter4fvNV_ ProgramParameter4fvNV_;
-        public static Delegates.ProgramParameters4dvNV_ ProgramParameters4dvNV_;
-        public static Delegates.ProgramParameters4fvNV_ ProgramParameters4fvNV_;
-        public static Delegates.RequestResidentProgramsNV_ RequestResidentProgramsNV_;
-        public static Delegates.TrackMatrixNV TrackMatrixNV;
-        public static Delegates.VertexAttribPointerNV_ VertexAttribPointerNV_;
-        public static Delegates.VertexAttrib1dNV VertexAttrib1dNV;
-        public static Delegates.VertexAttrib1dvNV_ VertexAttrib1dvNV_;
-        public static Delegates.VertexAttrib1fNV VertexAttrib1fNV;
-        public static Delegates.VertexAttrib1fvNV_ VertexAttrib1fvNV_;
-        public static Delegates.VertexAttrib1sNV VertexAttrib1sNV;
-        public static Delegates.VertexAttrib1svNV_ VertexAttrib1svNV_;
-        public static Delegates.VertexAttrib2dNV VertexAttrib2dNV;
-        public static Delegates.VertexAttrib2dvNV_ VertexAttrib2dvNV_;
-        public static Delegates.VertexAttrib2fNV VertexAttrib2fNV;
-        public static Delegates.VertexAttrib2fvNV_ VertexAttrib2fvNV_;
-        public static Delegates.VertexAttrib2sNV VertexAttrib2sNV;
-        public static Delegates.VertexAttrib2svNV_ VertexAttrib2svNV_;
-        public static Delegates.VertexAttrib3dNV VertexAttrib3dNV;
-        public static Delegates.VertexAttrib3dvNV_ VertexAttrib3dvNV_;
-        public static Delegates.VertexAttrib3fNV VertexAttrib3fNV;
-        public static Delegates.VertexAttrib3fvNV_ VertexAttrib3fvNV_;
-        public static Delegates.VertexAttrib3sNV VertexAttrib3sNV;
-        public static Delegates.VertexAttrib3svNV_ VertexAttrib3svNV_;
-        public static Delegates.VertexAttrib4dNV VertexAttrib4dNV;
-        public static Delegates.VertexAttrib4dvNV_ VertexAttrib4dvNV_;
-        public static Delegates.VertexAttrib4fNV VertexAttrib4fNV;
-        public static Delegates.VertexAttrib4fvNV_ VertexAttrib4fvNV_;
-        public static Delegates.VertexAttrib4sNV VertexAttrib4sNV;
-        public static Delegates.VertexAttrib4svNV_ VertexAttrib4svNV_;
-        public static Delegates.VertexAttrib4ubNV VertexAttrib4ubNV;
-        public static Delegates.VertexAttrib4ubvNV_ VertexAttrib4ubvNV_;
-        public static Delegates.VertexAttribs1dvNV_ VertexAttribs1dvNV_;
-        public static Delegates.VertexAttribs1fvNV_ VertexAttribs1fvNV_;
-        public static Delegates.VertexAttribs1svNV_ VertexAttribs1svNV_;
-        public static Delegates.VertexAttribs2dvNV_ VertexAttribs2dvNV_;
-        public static Delegates.VertexAttribs2fvNV_ VertexAttribs2fvNV_;
-        public static Delegates.VertexAttribs2svNV_ VertexAttribs2svNV_;
-        public static Delegates.VertexAttribs3dvNV_ VertexAttribs3dvNV_;
-        public static Delegates.VertexAttribs3fvNV_ VertexAttribs3fvNV_;
-        public static Delegates.VertexAttribs3svNV_ VertexAttribs3svNV_;
-        public static Delegates.VertexAttribs4dvNV_ VertexAttribs4dvNV_;
-        public static Delegates.VertexAttribs4fvNV_ VertexAttribs4fvNV_;
-        public static Delegates.VertexAttribs4svNV_ VertexAttribs4svNV_;
-        public static Delegates.VertexAttribs4ubvNV_ VertexAttribs4ubvNV_;
-        public static Delegates.TexBumpParameterivATI_ TexBumpParameterivATI_;
-        public static Delegates.TexBumpParameterfvATI_ TexBumpParameterfvATI_;
-        public static Delegates.GetTexBumpParameterivATI_ GetTexBumpParameterivATI_;
-        public static Delegates.GetTexBumpParameterfvATI_ GetTexBumpParameterfvATI_;
-        public static Delegates.GenFragmentShadersATI GenFragmentShadersATI;
-        public static Delegates.BindFragmentShaderATI BindFragmentShaderATI;
-        public static Delegates.DeleteFragmentShaderATI DeleteFragmentShaderATI;
-        public static Delegates.BeginFragmentShaderATI BeginFragmentShaderATI;
-        public static Delegates.EndFragmentShaderATI EndFragmentShaderATI;
-        public static Delegates.PassTexCoordATI PassTexCoordATI;
-        public static Delegates.SampleMapATI SampleMapATI;
-        public static Delegates.ColorFragmentOp1ATI ColorFragmentOp1ATI;
-        public static Delegates.ColorFragmentOp2ATI ColorFragmentOp2ATI;
-        public static Delegates.ColorFragmentOp3ATI ColorFragmentOp3ATI;
-        public static Delegates.AlphaFragmentOp1ATI AlphaFragmentOp1ATI;
-        public static Delegates.AlphaFragmentOp2ATI AlphaFragmentOp2ATI;
-        public static Delegates.AlphaFragmentOp3ATI AlphaFragmentOp3ATI;
-        public static Delegates.SetFragmentShaderConstantATI_ SetFragmentShaderConstantATI_;
-        public static Delegates.PNTrianglesiATI PNTrianglesiATI;
-        public static Delegates.PNTrianglesfATI PNTrianglesfATI;
-        public static Delegates.NewObjectBufferATI_ NewObjectBufferATI_;
-        public static Delegates.IsObjectBufferATI IsObjectBufferATI;
-        public static Delegates.UpdateObjectBufferATI_ UpdateObjectBufferATI_;
-        public static Delegates.GetObjectBufferfvATI_ GetObjectBufferfvATI_;
-        public static Delegates.GetObjectBufferivATI_ GetObjectBufferivATI_;
-        public static Delegates.FreeObjectBufferATI FreeObjectBufferATI;
-        public static Delegates.ArrayObjectATI ArrayObjectATI;
-        public static Delegates.GetArrayObjectfvATI_ GetArrayObjectfvATI_;
-        public static Delegates.GetArrayObjectivATI_ GetArrayObjectivATI_;
-        public static Delegates.VariantArrayObjectATI VariantArrayObjectATI;
-        public static Delegates.GetVariantArrayObjectfvATI_ GetVariantArrayObjectfvATI_;
-        public static Delegates.GetVariantArrayObjectivATI_ GetVariantArrayObjectivATI_;
-        public static Delegates.BeginVertexShaderEXT BeginVertexShaderEXT;
-        public static Delegates.EndVertexShaderEXT EndVertexShaderEXT;
-        public static Delegates.BindVertexShaderEXT BindVertexShaderEXT;
-        public static Delegates.GenVertexShadersEXT GenVertexShadersEXT;
-        public static Delegates.DeleteVertexShaderEXT DeleteVertexShaderEXT;
-        public static Delegates.ShaderOp1EXT ShaderOp1EXT;
-        public static Delegates.ShaderOp2EXT ShaderOp2EXT;
-        public static Delegates.ShaderOp3EXT ShaderOp3EXT;
-        public static Delegates.SwizzleEXT SwizzleEXT;
-        public static Delegates.WriteMaskEXT WriteMaskEXT;
-        public static Delegates.InsertComponentEXT InsertComponentEXT;
-        public static Delegates.ExtractComponentEXT ExtractComponentEXT;
-        public static Delegates.GenSymbolsEXT GenSymbolsEXT;
-        public static Delegates.SetInvariantEXT_ SetInvariantEXT_;
-        public static Delegates.SetLocalConstantEXT_ SetLocalConstantEXT_;
-        public static Delegates.VariantbvEXT_ VariantbvEXT_;
-        public static Delegates.VariantsvEXT_ VariantsvEXT_;
-        public static Delegates.VariantivEXT_ VariantivEXT_;
-        public static Delegates.VariantfvEXT_ VariantfvEXT_;
-        public static Delegates.VariantdvEXT_ VariantdvEXT_;
-        public static Delegates.VariantubvEXT_ VariantubvEXT_;
-        public static Delegates.VariantusvEXT_ VariantusvEXT_;
-        public static Delegates.VariantuivEXT_ VariantuivEXT_;
-        public static Delegates.VariantPointerEXT_ VariantPointerEXT_;
-        public static Delegates.EnableVariantClientStateEXT EnableVariantClientStateEXT;
-        public static Delegates.DisableVariantClientStateEXT DisableVariantClientStateEXT;
-        public static Delegates.BindLightParameterEXT BindLightParameterEXT;
-        public static Delegates.BindMaterialParameterEXT BindMaterialParameterEXT;
-        public static Delegates.BindTexGenParameterEXT BindTexGenParameterEXT;
-        public static Delegates.BindTextureUnitParameterEXT BindTextureUnitParameterEXT;
-        public static Delegates.BindParameterEXT BindParameterEXT;
-        public static Delegates.IsVariantEnabledEXT IsVariantEnabledEXT;
-        public static Delegates.GetVariantBooleanvEXT_ GetVariantBooleanvEXT_;
-        public static Delegates.GetVariantIntegervEXT_ GetVariantIntegervEXT_;
-        public static Delegates.GetVariantFloatvEXT_ GetVariantFloatvEXT_;
-        public static Delegates.GetVariantPointervEXT_ GetVariantPointervEXT_;
-        public static Delegates.GetInvariantBooleanvEXT_ GetInvariantBooleanvEXT_;
-        public static Delegates.GetInvariantIntegervEXT_ GetInvariantIntegervEXT_;
-        public static Delegates.GetInvariantFloatvEXT_ GetInvariantFloatvEXT_;
-        public static Delegates.GetLocalConstantBooleanvEXT_ GetLocalConstantBooleanvEXT_;
-        public static Delegates.GetLocalConstantIntegervEXT_ GetLocalConstantIntegervEXT_;
-        public static Delegates.GetLocalConstantFloatvEXT_ GetLocalConstantFloatvEXT_;
-        public static Delegates.VertexStream1sATI VertexStream1sATI;
-        public static Delegates.VertexStream1svATI_ VertexStream1svATI_;
-        public static Delegates.VertexStream1iATI VertexStream1iATI;
-        public static Delegates.VertexStream1ivATI_ VertexStream1ivATI_;
-        public static Delegates.VertexStream1fATI VertexStream1fATI;
-        public static Delegates.VertexStream1fvATI_ VertexStream1fvATI_;
-        public static Delegates.VertexStream1dATI VertexStream1dATI;
-        public static Delegates.VertexStream1dvATI_ VertexStream1dvATI_;
-        public static Delegates.VertexStream2sATI VertexStream2sATI;
-        public static Delegates.VertexStream2svATI_ VertexStream2svATI_;
-        public static Delegates.VertexStream2iATI VertexStream2iATI;
-        public static Delegates.VertexStream2ivATI_ VertexStream2ivATI_;
-        public static Delegates.VertexStream2fATI VertexStream2fATI;
-        public static Delegates.VertexStream2fvATI_ VertexStream2fvATI_;
-        public static Delegates.VertexStream2dATI VertexStream2dATI;
-        public static Delegates.VertexStream2dvATI_ VertexStream2dvATI_;
-        public static Delegates.VertexStream3sATI VertexStream3sATI;
-        public static Delegates.VertexStream3svATI_ VertexStream3svATI_;
-        public static Delegates.VertexStream3iATI VertexStream3iATI;
-        public static Delegates.VertexStream3ivATI_ VertexStream3ivATI_;
-        public static Delegates.VertexStream3fATI VertexStream3fATI;
-        public static Delegates.VertexStream3fvATI_ VertexStream3fvATI_;
-        public static Delegates.VertexStream3dATI VertexStream3dATI;
-        public static Delegates.VertexStream3dvATI_ VertexStream3dvATI_;
-        public static Delegates.VertexStream4sATI VertexStream4sATI;
-        public static Delegates.VertexStream4svATI_ VertexStream4svATI_;
-        public static Delegates.VertexStream4iATI VertexStream4iATI;
-        public static Delegates.VertexStream4ivATI_ VertexStream4ivATI_;
-        public static Delegates.VertexStream4fATI VertexStream4fATI;
-        public static Delegates.VertexStream4fvATI_ VertexStream4fvATI_;
-        public static Delegates.VertexStream4dATI VertexStream4dATI;
-        public static Delegates.VertexStream4dvATI_ VertexStream4dvATI_;
-        public static Delegates.NormalStream3bATI NormalStream3bATI;
-        public static Delegates.NormalStream3bvATI_ NormalStream3bvATI_;
-        public static Delegates.NormalStream3sATI NormalStream3sATI;
-        public static Delegates.NormalStream3svATI_ NormalStream3svATI_;
-        public static Delegates.NormalStream3iATI NormalStream3iATI;
-        public static Delegates.NormalStream3ivATI_ NormalStream3ivATI_;
-        public static Delegates.NormalStream3fATI NormalStream3fATI;
-        public static Delegates.NormalStream3fvATI_ NormalStream3fvATI_;
-        public static Delegates.NormalStream3dATI NormalStream3dATI;
-        public static Delegates.NormalStream3dvATI_ NormalStream3dvATI_;
-        public static Delegates.ClientActiveVertexStreamATI ClientActiveVertexStreamATI;
-        public static Delegates.VertexBlendEnviATI VertexBlendEnviATI;
-        public static Delegates.VertexBlendEnvfATI VertexBlendEnvfATI;
-        public static Delegates.ElementPointerATI_ ElementPointerATI_;
-        public static Delegates.DrawElementArrayATI DrawElementArrayATI;
-        public static Delegates.DrawRangeElementArrayATI DrawRangeElementArrayATI;
-        public static Delegates.DrawMeshArraysSUN DrawMeshArraysSUN;
-        public static Delegates.GenOcclusionQueriesNV_ GenOcclusionQueriesNV_;
-        public static Delegates.DeleteOcclusionQueriesNV_ DeleteOcclusionQueriesNV_;
-        public static Delegates.IsOcclusionQueryNV IsOcclusionQueryNV;
-        public static Delegates.BeginOcclusionQueryNV BeginOcclusionQueryNV;
-        public static Delegates.EndOcclusionQueryNV EndOcclusionQueryNV;
-        public static Delegates.GetOcclusionQueryivNV_ GetOcclusionQueryivNV_;
-        public static Delegates.GetOcclusionQueryuivNV_ GetOcclusionQueryuivNV_;
-        public static Delegates.PointParameteriNV PointParameteriNV;
-        public static Delegates.PointParameterivNV_ PointParameterivNV_;
-        public static Delegates.ActiveStencilFaceEXT ActiveStencilFaceEXT;
-        public static Delegates.ElementPointerAPPLE_ ElementPointerAPPLE_;
-        public static Delegates.DrawElementArrayAPPLE DrawElementArrayAPPLE;
-        public static Delegates.DrawRangeElementArrayAPPLE DrawRangeElementArrayAPPLE;
-        public static Delegates.MultiDrawElementArrayAPPLE_ MultiDrawElementArrayAPPLE_;
-        public static Delegates.MultiDrawRangeElementArrayAPPLE_ MultiDrawRangeElementArrayAPPLE_;
-        public static Delegates.GenFencesAPPLE_ GenFencesAPPLE_;
-        public static Delegates.DeleteFencesAPPLE_ DeleteFencesAPPLE_;
-        public static Delegates.SetFenceAPPLE SetFenceAPPLE;
-        public static Delegates.IsFenceAPPLE IsFenceAPPLE;
-        public static Delegates.TestFenceAPPLE TestFenceAPPLE;
-        public static Delegates.FinishFenceAPPLE FinishFenceAPPLE;
-        public static Delegates.TestObjectAPPLE TestObjectAPPLE;
-        public static Delegates.FinishObjectAPPLE FinishObjectAPPLE;
-        public static Delegates.BindVertexArrayAPPLE BindVertexArrayAPPLE;
-        public static Delegates.DeleteVertexArraysAPPLE_ DeleteVertexArraysAPPLE_;
-        public static Delegates.GenVertexArraysAPPLE_ GenVertexArraysAPPLE_;
-        public static Delegates.IsVertexArrayAPPLE IsVertexArrayAPPLE;
-        public static Delegates.VertexArrayRangeAPPLE_ VertexArrayRangeAPPLE_;
-        public static Delegates.FlushVertexArrayRangeAPPLE_ FlushVertexArrayRangeAPPLE_;
-        public static Delegates.VertexArrayParameteriAPPLE VertexArrayParameteriAPPLE;
-        public static Delegates.DrawBuffersATI_ DrawBuffersATI_;
-        public static Delegates.ProgramNamedParameter4fNV_ ProgramNamedParameter4fNV_;
-        public static Delegates.ProgramNamedParameter4dNV_ ProgramNamedParameter4dNV_;
-        public static Delegates.ProgramNamedParameter4fvNV_ ProgramNamedParameter4fvNV_;
-        public static Delegates.ProgramNamedParameter4dvNV_ ProgramNamedParameter4dvNV_;
-        public static Delegates.GetProgramNamedParameterfvNV_ GetProgramNamedParameterfvNV_;
-        public static Delegates.GetProgramNamedParameterdvNV_ GetProgramNamedParameterdvNV_;
-        public static Delegates.Vertex2hNV Vertex2hNV;
-        public static Delegates.Vertex2hvNV_ Vertex2hvNV_;
-        public static Delegates.Vertex3hNV Vertex3hNV;
-        public static Delegates.Vertex3hvNV_ Vertex3hvNV_;
-        public static Delegates.Vertex4hNV Vertex4hNV;
-        public static Delegates.Vertex4hvNV_ Vertex4hvNV_;
-        public static Delegates.Normal3hNV Normal3hNV;
-        public static Delegates.Normal3hvNV_ Normal3hvNV_;
-        public static Delegates.Color3hNV Color3hNV;
-        public static Delegates.Color3hvNV_ Color3hvNV_;
-        public static Delegates.Color4hNV Color4hNV;
-        public static Delegates.Color4hvNV_ Color4hvNV_;
-        public static Delegates.TexCoord1hNV TexCoord1hNV;
-        public static Delegates.TexCoord1hvNV_ TexCoord1hvNV_;
-        public static Delegates.TexCoord2hNV TexCoord2hNV;
-        public static Delegates.TexCoord2hvNV_ TexCoord2hvNV_;
-        public static Delegates.TexCoord3hNV TexCoord3hNV;
-        public static Delegates.TexCoord3hvNV_ TexCoord3hvNV_;
-        public static Delegates.TexCoord4hNV TexCoord4hNV;
-        public static Delegates.TexCoord4hvNV_ TexCoord4hvNV_;
-        public static Delegates.MultiTexCoord1hNV MultiTexCoord1hNV;
-        public static Delegates.MultiTexCoord1hvNV_ MultiTexCoord1hvNV_;
-        public static Delegates.MultiTexCoord2hNV MultiTexCoord2hNV;
-        public static Delegates.MultiTexCoord2hvNV_ MultiTexCoord2hvNV_;
-        public static Delegates.MultiTexCoord3hNV MultiTexCoord3hNV;
-        public static Delegates.MultiTexCoord3hvNV_ MultiTexCoord3hvNV_;
-        public static Delegates.MultiTexCoord4hNV MultiTexCoord4hNV;
-        public static Delegates.MultiTexCoord4hvNV_ MultiTexCoord4hvNV_;
-        public static Delegates.FogCoordhNV FogCoordhNV;
-        public static Delegates.FogCoordhvNV_ FogCoordhvNV_;
-        public static Delegates.SecondaryColor3hNV SecondaryColor3hNV;
-        public static Delegates.SecondaryColor3hvNV_ SecondaryColor3hvNV_;
-        public static Delegates.VertexWeighthNV VertexWeighthNV;
-        public static Delegates.VertexWeighthvNV_ VertexWeighthvNV_;
-        public static Delegates.VertexAttrib1hNV VertexAttrib1hNV;
-        public static Delegates.VertexAttrib1hvNV_ VertexAttrib1hvNV_;
-        public static Delegates.VertexAttrib2hNV VertexAttrib2hNV;
-        public static Delegates.VertexAttrib2hvNV_ VertexAttrib2hvNV_;
-        public static Delegates.VertexAttrib3hNV VertexAttrib3hNV;
-        public static Delegates.VertexAttrib3hvNV_ VertexAttrib3hvNV_;
-        public static Delegates.VertexAttrib4hNV VertexAttrib4hNV;
-        public static Delegates.VertexAttrib4hvNV_ VertexAttrib4hvNV_;
-        public static Delegates.VertexAttribs1hvNV_ VertexAttribs1hvNV_;
-        public static Delegates.VertexAttribs2hvNV_ VertexAttribs2hvNV_;
-        public static Delegates.VertexAttribs3hvNV_ VertexAttribs3hvNV_;
-        public static Delegates.VertexAttribs4hvNV_ VertexAttribs4hvNV_;
-        public static Delegates.PixelDataRangeNV_ PixelDataRangeNV_;
-        public static Delegates.FlushPixelDataRangeNV FlushPixelDataRangeNV;
-        public static Delegates.PrimitiveRestartNV PrimitiveRestartNV;
-        public static Delegates.PrimitiveRestartIndexNV PrimitiveRestartIndexNV;
-        public static Delegates.MapObjectBufferATI MapObjectBufferATI;
-        public static Delegates.UnmapObjectBufferATI UnmapObjectBufferATI;
-        public static Delegates.StencilOpSeparateATI StencilOpSeparateATI;
-        public static Delegates.StencilFuncSeparateATI StencilFuncSeparateATI;
-        public static Delegates.VertexAttribArrayObjectATI VertexAttribArrayObjectATI;
-        public static Delegates.GetVertexAttribArrayObjectfvATI_ GetVertexAttribArrayObjectfvATI_;
-        public static Delegates.GetVertexAttribArrayObjectivATI_ GetVertexAttribArrayObjectivATI_;
-        public static Delegates.DepthBoundsEXT DepthBoundsEXT;
-        public static Delegates.BlendEquationSeparateEXT BlendEquationSeparateEXT;
-        public static Delegates.IsRenderbufferEXT IsRenderbufferEXT;
-        public static Delegates.BindRenderbufferEXT BindRenderbufferEXT;
-        public static Delegates.DeleteRenderbuffersEXT_ DeleteRenderbuffersEXT_;
-        public static Delegates.GenRenderbuffersEXT_ GenRenderbuffersEXT_;
-        public static Delegates.RenderbufferStorageEXT RenderbufferStorageEXT;
-        public static Delegates.GetRenderbufferParameterivEXT_ GetRenderbufferParameterivEXT_;
-        public static Delegates.IsFramebufferEXT IsFramebufferEXT;
-        public static Delegates.BindFramebufferEXT BindFramebufferEXT;
-        public static Delegates.DeleteFramebuffersEXT_ DeleteFramebuffersEXT_;
-        public static Delegates.GenFramebuffersEXT_ GenFramebuffersEXT_;
-        public static Delegates.CheckFramebufferStatusEXT CheckFramebufferStatusEXT;
-        public static Delegates.FramebufferTexture1DEXT FramebufferTexture1DEXT;
-        public static Delegates.FramebufferTexture2DEXT FramebufferTexture2DEXT;
-        public static Delegates.FramebufferTexture3DEXT FramebufferTexture3DEXT;
-        public static Delegates.FramebufferRenderbufferEXT FramebufferRenderbufferEXT;
-        public static Delegates.GetFramebufferAttachmentParameterivEXT_ GetFramebufferAttachmentParameterivEXT_;
-        public static Delegates.GenerateMipmapEXT GenerateMipmapEXT;
-        public static Delegates.StringMarkerGREMEDY_ StringMarkerGREMEDY_;
-        public static Delegates.StencilClearTagEXT StencilClearTagEXT;
-        public static Delegates.BlitFramebufferEXT BlitFramebufferEXT;
-        public static Delegates.RenderbufferStorageMultisampleEXT RenderbufferStorageMultisampleEXT;
-        public static Delegates.GetQueryObjecti64vEXT_ GetQueryObjecti64vEXT_;
-        public static Delegates.GetQueryObjectui64vEXT_ GetQueryObjectui64vEXT_;
-        public static Delegates.ProgramEnvParameters4fvEXT_ ProgramEnvParameters4fvEXT_;
-        public static Delegates.ProgramLocalParameters4fvEXT_ ProgramLocalParameters4fvEXT_;
+        public static Delegates.NewList NewList = new Delegates.NewList(Imports.NewList);
+        public static Delegates.EndList EndList = new Delegates.EndList(Imports.EndList);
+        public static Delegates.CallList CallList = new Delegates.CallList(Imports.CallList);
+        public static Delegates.CallLists_ CallLists_ = new Delegates.CallLists_(Imports.CallLists_);
+        public static Delegates.DeleteLists DeleteLists = new Delegates.DeleteLists(Imports.DeleteLists);
+        public static Delegates.GenLists GenLists = new Delegates.GenLists(Imports.GenLists);
+        public static Delegates.ListBase ListBase = new Delegates.ListBase(Imports.ListBase);
+        public static Delegates.Begin Begin = new Delegates.Begin(Imports.Begin);
+        public static Delegates.Bitmap_ Bitmap_ = new Delegates.Bitmap_(Imports.Bitmap_);
+        public static Delegates.Color3b Color3b = new Delegates.Color3b(Imports.Color3b);
+        public static Delegates.Color3bv_ Color3bv_ = new Delegates.Color3bv_(Imports.Color3bv_);
+        public static Delegates.Color3d Color3d = new Delegates.Color3d(Imports.Color3d);
+        public static Delegates.Color3dv_ Color3dv_ = new Delegates.Color3dv_(Imports.Color3dv_);
+        public static Delegates.Color3f Color3f = new Delegates.Color3f(Imports.Color3f);
+        public static Delegates.Color3fv_ Color3fv_ = new Delegates.Color3fv_(Imports.Color3fv_);
+        public static Delegates.Color3i Color3i = new Delegates.Color3i(Imports.Color3i);
+        public static Delegates.Color3iv_ Color3iv_ = new Delegates.Color3iv_(Imports.Color3iv_);
+        public static Delegates.Color3s Color3s = new Delegates.Color3s(Imports.Color3s);
+        public static Delegates.Color3sv_ Color3sv_ = new Delegates.Color3sv_(Imports.Color3sv_);
+        public static Delegates.Color3ub Color3ub = new Delegates.Color3ub(Imports.Color3ub);
+        public static Delegates.Color3ubv_ Color3ubv_ = new Delegates.Color3ubv_(Imports.Color3ubv_);
+        public static Delegates.Color3ui Color3ui = new Delegates.Color3ui(Imports.Color3ui);
+        public static Delegates.Color3uiv_ Color3uiv_ = new Delegates.Color3uiv_(Imports.Color3uiv_);
+        public static Delegates.Color3us Color3us = new Delegates.Color3us(Imports.Color3us);
+        public static Delegates.Color3usv_ Color3usv_ = new Delegates.Color3usv_(Imports.Color3usv_);
+        public static Delegates.Color4b Color4b = new Delegates.Color4b(Imports.Color4b);
+        public static Delegates.Color4bv_ Color4bv_ = new Delegates.Color4bv_(Imports.Color4bv_);
+        public static Delegates.Color4d Color4d = new Delegates.Color4d(Imports.Color4d);
+        public static Delegates.Color4dv_ Color4dv_ = new Delegates.Color4dv_(Imports.Color4dv_);
+        public static Delegates.Color4f Color4f = new Delegates.Color4f(Imports.Color4f);
+        public static Delegates.Color4fv_ Color4fv_ = new Delegates.Color4fv_(Imports.Color4fv_);
+        public static Delegates.Color4i Color4i = new Delegates.Color4i(Imports.Color4i);
+        public static Delegates.Color4iv_ Color4iv_ = new Delegates.Color4iv_(Imports.Color4iv_);
+        public static Delegates.Color4s Color4s = new Delegates.Color4s(Imports.Color4s);
+        public static Delegates.Color4sv_ Color4sv_ = new Delegates.Color4sv_(Imports.Color4sv_);
+        public static Delegates.Color4ub Color4ub = new Delegates.Color4ub(Imports.Color4ub);
+        public static Delegates.Color4ubv_ Color4ubv_ = new Delegates.Color4ubv_(Imports.Color4ubv_);
+        public static Delegates.Color4ui Color4ui = new Delegates.Color4ui(Imports.Color4ui);
+        public static Delegates.Color4uiv_ Color4uiv_ = new Delegates.Color4uiv_(Imports.Color4uiv_);
+        public static Delegates.Color4us Color4us = new Delegates.Color4us(Imports.Color4us);
+        public static Delegates.Color4usv_ Color4usv_ = new Delegates.Color4usv_(Imports.Color4usv_);
+        public static Delegates.EdgeFlag EdgeFlag = new Delegates.EdgeFlag(Imports.EdgeFlag);
+        public static Delegates.EdgeFlagv_ EdgeFlagv_ = new Delegates.EdgeFlagv_(Imports.EdgeFlagv_);
+        public static Delegates.End End = new Delegates.End(Imports.End);
+        public static Delegates.Indexd Indexd = new Delegates.Indexd(Imports.Indexd);
+        public static Delegates.Indexdv_ Indexdv_ = new Delegates.Indexdv_(Imports.Indexdv_);
+        public static Delegates.Indexf Indexf = new Delegates.Indexf(Imports.Indexf);
+        public static Delegates.Indexfv_ Indexfv_ = new Delegates.Indexfv_(Imports.Indexfv_);
+        public static Delegates.Indexi Indexi = new Delegates.Indexi(Imports.Indexi);
+        public static Delegates.Indexiv_ Indexiv_ = new Delegates.Indexiv_(Imports.Indexiv_);
+        public static Delegates.Indexs Indexs = new Delegates.Indexs(Imports.Indexs);
+        public static Delegates.Indexsv_ Indexsv_ = new Delegates.Indexsv_(Imports.Indexsv_);
+        public static Delegates.Normal3b Normal3b = new Delegates.Normal3b(Imports.Normal3b);
+        public static Delegates.Normal3bv_ Normal3bv_ = new Delegates.Normal3bv_(Imports.Normal3bv_);
+        public static Delegates.Normal3d Normal3d = new Delegates.Normal3d(Imports.Normal3d);
+        public static Delegates.Normal3dv_ Normal3dv_ = new Delegates.Normal3dv_(Imports.Normal3dv_);
+        public static Delegates.Normal3f Normal3f = new Delegates.Normal3f(Imports.Normal3f);
+        public static Delegates.Normal3fv_ Normal3fv_ = new Delegates.Normal3fv_(Imports.Normal3fv_);
+        public static Delegates.Normal3i Normal3i = new Delegates.Normal3i(Imports.Normal3i);
+        public static Delegates.Normal3iv_ Normal3iv_ = new Delegates.Normal3iv_(Imports.Normal3iv_);
+        public static Delegates.Normal3s Normal3s = new Delegates.Normal3s(Imports.Normal3s);
+        public static Delegates.Normal3sv_ Normal3sv_ = new Delegates.Normal3sv_(Imports.Normal3sv_);
+        public static Delegates.RasterPos2d RasterPos2d = new Delegates.RasterPos2d(Imports.RasterPos2d);
+        public static Delegates.RasterPos2dv_ RasterPos2dv_ = new Delegates.RasterPos2dv_(Imports.RasterPos2dv_);
+        public static Delegates.RasterPos2f RasterPos2f = new Delegates.RasterPos2f(Imports.RasterPos2f);
+        public static Delegates.RasterPos2fv_ RasterPos2fv_ = new Delegates.RasterPos2fv_(Imports.RasterPos2fv_);
+        public static Delegates.RasterPos2i RasterPos2i = new Delegates.RasterPos2i(Imports.RasterPos2i);
+        public static Delegates.RasterPos2iv_ RasterPos2iv_ = new Delegates.RasterPos2iv_(Imports.RasterPos2iv_);
+        public static Delegates.RasterPos2s RasterPos2s = new Delegates.RasterPos2s(Imports.RasterPos2s);
+        public static Delegates.RasterPos2sv_ RasterPos2sv_ = new Delegates.RasterPos2sv_(Imports.RasterPos2sv_);
+        public static Delegates.RasterPos3d RasterPos3d = new Delegates.RasterPos3d(Imports.RasterPos3d);
+        public static Delegates.RasterPos3dv_ RasterPos3dv_ = new Delegates.RasterPos3dv_(Imports.RasterPos3dv_);
+        public static Delegates.RasterPos3f RasterPos3f = new Delegates.RasterPos3f(Imports.RasterPos3f);
+        public static Delegates.RasterPos3fv_ RasterPos3fv_ = new Delegates.RasterPos3fv_(Imports.RasterPos3fv_);
+        public static Delegates.RasterPos3i RasterPos3i = new Delegates.RasterPos3i(Imports.RasterPos3i);
+        public static Delegates.RasterPos3iv_ RasterPos3iv_ = new Delegates.RasterPos3iv_(Imports.RasterPos3iv_);
+        public static Delegates.RasterPos3s RasterPos3s = new Delegates.RasterPos3s(Imports.RasterPos3s);
+        public static Delegates.RasterPos3sv_ RasterPos3sv_ = new Delegates.RasterPos3sv_(Imports.RasterPos3sv_);
+        public static Delegates.RasterPos4d RasterPos4d = new Delegates.RasterPos4d(Imports.RasterPos4d);
+        public static Delegates.RasterPos4dv_ RasterPos4dv_ = new Delegates.RasterPos4dv_(Imports.RasterPos4dv_);
+        public static Delegates.RasterPos4f RasterPos4f = new Delegates.RasterPos4f(Imports.RasterPos4f);
+        public static Delegates.RasterPos4fv_ RasterPos4fv_ = new Delegates.RasterPos4fv_(Imports.RasterPos4fv_);
+        public static Delegates.RasterPos4i RasterPos4i = new Delegates.RasterPos4i(Imports.RasterPos4i);
+        public static Delegates.RasterPos4iv_ RasterPos4iv_ = new Delegates.RasterPos4iv_(Imports.RasterPos4iv_);
+        public static Delegates.RasterPos4s RasterPos4s = new Delegates.RasterPos4s(Imports.RasterPos4s);
+        public static Delegates.RasterPos4sv_ RasterPos4sv_ = new Delegates.RasterPos4sv_(Imports.RasterPos4sv_);
+        public static Delegates.Rectd Rectd = new Delegates.Rectd(Imports.Rectd);
+        public static Delegates.Rectdv_ Rectdv_ = new Delegates.Rectdv_(Imports.Rectdv_);
+        public static Delegates.Rectf Rectf = new Delegates.Rectf(Imports.Rectf);
+        public static Delegates.Rectfv_ Rectfv_ = new Delegates.Rectfv_(Imports.Rectfv_);
+        public static Delegates.Recti Recti = new Delegates.Recti(Imports.Recti);
+        public static Delegates.Rectiv_ Rectiv_ = new Delegates.Rectiv_(Imports.Rectiv_);
+        public static Delegates.Rects Rects = new Delegates.Rects(Imports.Rects);
+        public static Delegates.Rectsv_ Rectsv_ = new Delegates.Rectsv_(Imports.Rectsv_);
+        public static Delegates.TexCoord1d TexCoord1d = new Delegates.TexCoord1d(Imports.TexCoord1d);
+        public static Delegates.TexCoord1dv_ TexCoord1dv_ = new Delegates.TexCoord1dv_(Imports.TexCoord1dv_);
+        public static Delegates.TexCoord1f TexCoord1f = new Delegates.TexCoord1f(Imports.TexCoord1f);
+        public static Delegates.TexCoord1fv_ TexCoord1fv_ = new Delegates.TexCoord1fv_(Imports.TexCoord1fv_);
+        public static Delegates.TexCoord1i TexCoord1i = new Delegates.TexCoord1i(Imports.TexCoord1i);
+        public static Delegates.TexCoord1iv_ TexCoord1iv_ = new Delegates.TexCoord1iv_(Imports.TexCoord1iv_);
+        public static Delegates.TexCoord1s TexCoord1s = new Delegates.TexCoord1s(Imports.TexCoord1s);
+        public static Delegates.TexCoord1sv_ TexCoord1sv_ = new Delegates.TexCoord1sv_(Imports.TexCoord1sv_);
+        public static Delegates.TexCoord2d TexCoord2d = new Delegates.TexCoord2d(Imports.TexCoord2d);
+        public static Delegates.TexCoord2dv_ TexCoord2dv_ = new Delegates.TexCoord2dv_(Imports.TexCoord2dv_);
+        public static Delegates.TexCoord2f TexCoord2f = new Delegates.TexCoord2f(Imports.TexCoord2f);
+        public static Delegates.TexCoord2fv_ TexCoord2fv_ = new Delegates.TexCoord2fv_(Imports.TexCoord2fv_);
+        public static Delegates.TexCoord2i TexCoord2i = new Delegates.TexCoord2i(Imports.TexCoord2i);
+        public static Delegates.TexCoord2iv_ TexCoord2iv_ = new Delegates.TexCoord2iv_(Imports.TexCoord2iv_);
+        public static Delegates.TexCoord2s TexCoord2s = new Delegates.TexCoord2s(Imports.TexCoord2s);
+        public static Delegates.TexCoord2sv_ TexCoord2sv_ = new Delegates.TexCoord2sv_(Imports.TexCoord2sv_);
+        public static Delegates.TexCoord3d TexCoord3d = new Delegates.TexCoord3d(Imports.TexCoord3d);
+        public static Delegates.TexCoord3dv_ TexCoord3dv_ = new Delegates.TexCoord3dv_(Imports.TexCoord3dv_);
+        public static Delegates.TexCoord3f TexCoord3f = new Delegates.TexCoord3f(Imports.TexCoord3f);
+        public static Delegates.TexCoord3fv_ TexCoord3fv_ = new Delegates.TexCoord3fv_(Imports.TexCoord3fv_);
+        public static Delegates.TexCoord3i TexCoord3i = new Delegates.TexCoord3i(Imports.TexCoord3i);
+        public static Delegates.TexCoord3iv_ TexCoord3iv_ = new Delegates.TexCoord3iv_(Imports.TexCoord3iv_);
+        public static Delegates.TexCoord3s TexCoord3s = new Delegates.TexCoord3s(Imports.TexCoord3s);
+        public static Delegates.TexCoord3sv_ TexCoord3sv_ = new Delegates.TexCoord3sv_(Imports.TexCoord3sv_);
+        public static Delegates.TexCoord4d TexCoord4d = new Delegates.TexCoord4d(Imports.TexCoord4d);
+        public static Delegates.TexCoord4dv_ TexCoord4dv_ = new Delegates.TexCoord4dv_(Imports.TexCoord4dv_);
+        public static Delegates.TexCoord4f TexCoord4f = new Delegates.TexCoord4f(Imports.TexCoord4f);
+        public static Delegates.TexCoord4fv_ TexCoord4fv_ = new Delegates.TexCoord4fv_(Imports.TexCoord4fv_);
+        public static Delegates.TexCoord4i TexCoord4i = new Delegates.TexCoord4i(Imports.TexCoord4i);
+        public static Delegates.TexCoord4iv_ TexCoord4iv_ = new Delegates.TexCoord4iv_(Imports.TexCoord4iv_);
+        public static Delegates.TexCoord4s TexCoord4s = new Delegates.TexCoord4s(Imports.TexCoord4s);
+        public static Delegates.TexCoord4sv_ TexCoord4sv_ = new Delegates.TexCoord4sv_(Imports.TexCoord4sv_);
+        public static Delegates.Vertex2d Vertex2d = new Delegates.Vertex2d(Imports.Vertex2d);
+        public static Delegates.Vertex2dv_ Vertex2dv_ = new Delegates.Vertex2dv_(Imports.Vertex2dv_);
+        public static Delegates.Vertex2f Vertex2f = new Delegates.Vertex2f(Imports.Vertex2f);
+        public static Delegates.Vertex2fv_ Vertex2fv_ = new Delegates.Vertex2fv_(Imports.Vertex2fv_);
+        public static Delegates.Vertex2i Vertex2i = new Delegates.Vertex2i(Imports.Vertex2i);
+        public static Delegates.Vertex2iv_ Vertex2iv_ = new Delegates.Vertex2iv_(Imports.Vertex2iv_);
+        public static Delegates.Vertex2s Vertex2s = new Delegates.Vertex2s(Imports.Vertex2s);
+        public static Delegates.Vertex2sv_ Vertex2sv_ = new Delegates.Vertex2sv_(Imports.Vertex2sv_);
+        public static Delegates.Vertex3d Vertex3d = new Delegates.Vertex3d(Imports.Vertex3d);
+        public static Delegates.Vertex3dv_ Vertex3dv_ = new Delegates.Vertex3dv_(Imports.Vertex3dv_);
+        public static Delegates.Vertex3f Vertex3f = new Delegates.Vertex3f(Imports.Vertex3f);
+        public static Delegates.Vertex3fv_ Vertex3fv_ = new Delegates.Vertex3fv_(Imports.Vertex3fv_);
+        public static Delegates.Vertex3i Vertex3i = new Delegates.Vertex3i(Imports.Vertex3i);
+        public static Delegates.Vertex3iv_ Vertex3iv_ = new Delegates.Vertex3iv_(Imports.Vertex3iv_);
+        public static Delegates.Vertex3s Vertex3s = new Delegates.Vertex3s(Imports.Vertex3s);
+        public static Delegates.Vertex3sv_ Vertex3sv_ = new Delegates.Vertex3sv_(Imports.Vertex3sv_);
+        public static Delegates.Vertex4d Vertex4d = new Delegates.Vertex4d(Imports.Vertex4d);
+        public static Delegates.Vertex4dv_ Vertex4dv_ = new Delegates.Vertex4dv_(Imports.Vertex4dv_);
+        public static Delegates.Vertex4f Vertex4f = new Delegates.Vertex4f(Imports.Vertex4f);
+        public static Delegates.Vertex4fv_ Vertex4fv_ = new Delegates.Vertex4fv_(Imports.Vertex4fv_);
+        public static Delegates.Vertex4i Vertex4i = new Delegates.Vertex4i(Imports.Vertex4i);
+        public static Delegates.Vertex4iv_ Vertex4iv_ = new Delegates.Vertex4iv_(Imports.Vertex4iv_);
+        public static Delegates.Vertex4s Vertex4s = new Delegates.Vertex4s(Imports.Vertex4s);
+        public static Delegates.Vertex4sv_ Vertex4sv_ = new Delegates.Vertex4sv_(Imports.Vertex4sv_);
+        public static Delegates.ClipPlane_ ClipPlane_ = new Delegates.ClipPlane_(Imports.ClipPlane_);
+        public static Delegates.ColorMaterial ColorMaterial = new Delegates.ColorMaterial(Imports.ColorMaterial);
+        public static Delegates.CullFace CullFace = new Delegates.CullFace(Imports.CullFace);
+        public static Delegates.Fogf Fogf = new Delegates.Fogf(Imports.Fogf);
+        public static Delegates.Fogfv_ Fogfv_ = new Delegates.Fogfv_(Imports.Fogfv_);
+        public static Delegates.Fogi Fogi = new Delegates.Fogi(Imports.Fogi);
+        public static Delegates.Fogiv_ Fogiv_ = new Delegates.Fogiv_(Imports.Fogiv_);
+        public static Delegates.FrontFace FrontFace = new Delegates.FrontFace(Imports.FrontFace);
+        public static Delegates.Hint Hint = new Delegates.Hint(Imports.Hint);
+        public static Delegates.Lightf Lightf = new Delegates.Lightf(Imports.Lightf);
+        public static Delegates.Lightfv_ Lightfv_ = new Delegates.Lightfv_(Imports.Lightfv_);
+        public static Delegates.Lighti Lighti = new Delegates.Lighti(Imports.Lighti);
+        public static Delegates.Lightiv_ Lightiv_ = new Delegates.Lightiv_(Imports.Lightiv_);
+        public static Delegates.LightModelf LightModelf = new Delegates.LightModelf(Imports.LightModelf);
+        public static Delegates.LightModelfv_ LightModelfv_ = new Delegates.LightModelfv_(Imports.LightModelfv_);
+        public static Delegates.LightModeli LightModeli = new Delegates.LightModeli(Imports.LightModeli);
+        public static Delegates.LightModeliv_ LightModeliv_ = new Delegates.LightModeliv_(Imports.LightModeliv_);
+        public static Delegates.LineStipple_ LineStipple_ = new Delegates.LineStipple_(Imports.LineStipple_);
+        public static Delegates.LineWidth LineWidth = new Delegates.LineWidth(Imports.LineWidth);
+        public static Delegates.Materialf Materialf = new Delegates.Materialf(Imports.Materialf);
+        public static Delegates.Materialfv_ Materialfv_ = new Delegates.Materialfv_(Imports.Materialfv_);
+        public static Delegates.Materiali Materiali = new Delegates.Materiali(Imports.Materiali);
+        public static Delegates.Materialiv_ Materialiv_ = new Delegates.Materialiv_(Imports.Materialiv_);
+        public static Delegates.PointSize PointSize = new Delegates.PointSize(Imports.PointSize);
+        public static Delegates.PolygonMode PolygonMode = new Delegates.PolygonMode(Imports.PolygonMode);
+        public static Delegates.PolygonStipple_ PolygonStipple_ = new Delegates.PolygonStipple_(Imports.PolygonStipple_);
+        public static Delegates.Scissor Scissor = new Delegates.Scissor(Imports.Scissor);
+        public static Delegates.ShadeModel ShadeModel = new Delegates.ShadeModel(Imports.ShadeModel);
+        public static Delegates.TexParameterf TexParameterf = new Delegates.TexParameterf(Imports.TexParameterf);
+        public static Delegates.TexParameterfv_ TexParameterfv_ = new Delegates.TexParameterfv_(Imports.TexParameterfv_);
+        public static Delegates.TexParameteri TexParameteri = new Delegates.TexParameteri(Imports.TexParameteri);
+        public static Delegates.TexParameteriv_ TexParameteriv_ = new Delegates.TexParameteriv_(Imports.TexParameteriv_);
+        public static Delegates.TexImage1D_ TexImage1D_ = new Delegates.TexImage1D_(Imports.TexImage1D_);
+        public static Delegates.TexImage2D_ TexImage2D_ = new Delegates.TexImage2D_(Imports.TexImage2D_);
+        public static Delegates.TexEnvf TexEnvf = new Delegates.TexEnvf(Imports.TexEnvf);
+        public static Delegates.TexEnvfv_ TexEnvfv_ = new Delegates.TexEnvfv_(Imports.TexEnvfv_);
+        public static Delegates.TexEnvi TexEnvi = new Delegates.TexEnvi(Imports.TexEnvi);
+        public static Delegates.TexEnviv_ TexEnviv_ = new Delegates.TexEnviv_(Imports.TexEnviv_);
+        public static Delegates.TexGend TexGend = new Delegates.TexGend(Imports.TexGend);
+        public static Delegates.TexGendv_ TexGendv_ = new Delegates.TexGendv_(Imports.TexGendv_);
+        public static Delegates.TexGenf TexGenf = new Delegates.TexGenf(Imports.TexGenf);
+        public static Delegates.TexGenfv_ TexGenfv_ = new Delegates.TexGenfv_(Imports.TexGenfv_);
+        public static Delegates.TexGeni TexGeni = new Delegates.TexGeni(Imports.TexGeni);
+        public static Delegates.TexGeniv_ TexGeniv_ = new Delegates.TexGeniv_(Imports.TexGeniv_);
+        public static Delegates.FeedbackBuffer_ FeedbackBuffer_ = new Delegates.FeedbackBuffer_(Imports.FeedbackBuffer_);
+        public static Delegates.SelectBuffer_ SelectBuffer_ = new Delegates.SelectBuffer_(Imports.SelectBuffer_);
+        public static Delegates.RenderMode RenderMode = new Delegates.RenderMode(Imports.RenderMode);
+        public static Delegates.InitNames InitNames = new Delegates.InitNames(Imports.InitNames);
+        public static Delegates.LoadName LoadName = new Delegates.LoadName(Imports.LoadName);
+        public static Delegates.PassThrough PassThrough = new Delegates.PassThrough(Imports.PassThrough);
+        public static Delegates.PopName PopName = new Delegates.PopName(Imports.PopName);
+        public static Delegates.PushName PushName = new Delegates.PushName(Imports.PushName);
+        public static Delegates.DrawBuffer DrawBuffer = new Delegates.DrawBuffer(Imports.DrawBuffer);
+        public static Delegates.Clear Clear = new Delegates.Clear(Imports.Clear);
+        public static Delegates.ClearAccum ClearAccum = new Delegates.ClearAccum(Imports.ClearAccum);
+        public static Delegates.ClearIndex ClearIndex = new Delegates.ClearIndex(Imports.ClearIndex);
+        public static Delegates.ClearColor ClearColor = new Delegates.ClearColor(Imports.ClearColor);
+        public static Delegates.ClearStencil ClearStencil = new Delegates.ClearStencil(Imports.ClearStencil);
+        public static Delegates.ClearDepth ClearDepth = new Delegates.ClearDepth(Imports.ClearDepth);
+        public static Delegates.StencilMask StencilMask = new Delegates.StencilMask(Imports.StencilMask);
+        public static Delegates.ColorMask ColorMask = new Delegates.ColorMask(Imports.ColorMask);
+        public static Delegates.DepthMask DepthMask = new Delegates.DepthMask(Imports.DepthMask);
+        public static Delegates.IndexMask IndexMask = new Delegates.IndexMask(Imports.IndexMask);
+        public static Delegates.Accum Accum = new Delegates.Accum(Imports.Accum);
+        public static Delegates.Disable Disable = new Delegates.Disable(Imports.Disable);
+        public static Delegates.Enable Enable = new Delegates.Enable(Imports.Enable);
+        public static Delegates.Finish Finish = new Delegates.Finish(Imports.Finish);
+        public static Delegates.Flush Flush = new Delegates.Flush(Imports.Flush);
+        public static Delegates.PopAttrib PopAttrib = new Delegates.PopAttrib(Imports.PopAttrib);
+        public static Delegates.PushAttrib PushAttrib = new Delegates.PushAttrib(Imports.PushAttrib);
+        public static Delegates.Map1d_ Map1d_ = new Delegates.Map1d_(Imports.Map1d_);
+        public static Delegates.Map1f_ Map1f_ = new Delegates.Map1f_(Imports.Map1f_);
+        public static Delegates.Map2d_ Map2d_ = new Delegates.Map2d_(Imports.Map2d_);
+        public static Delegates.Map2f_ Map2f_ = new Delegates.Map2f_(Imports.Map2f_);
+        public static Delegates.MapGrid1d MapGrid1d = new Delegates.MapGrid1d(Imports.MapGrid1d);
+        public static Delegates.MapGrid1f MapGrid1f = new Delegates.MapGrid1f(Imports.MapGrid1f);
+        public static Delegates.MapGrid2d MapGrid2d = new Delegates.MapGrid2d(Imports.MapGrid2d);
+        public static Delegates.MapGrid2f MapGrid2f = new Delegates.MapGrid2f(Imports.MapGrid2f);
+        public static Delegates.EvalCoord1d EvalCoord1d = new Delegates.EvalCoord1d(Imports.EvalCoord1d);
+        public static Delegates.EvalCoord1dv_ EvalCoord1dv_ = new Delegates.EvalCoord1dv_(Imports.EvalCoord1dv_);
+        public static Delegates.EvalCoord1f EvalCoord1f = new Delegates.EvalCoord1f(Imports.EvalCoord1f);
+        public static Delegates.EvalCoord1fv_ EvalCoord1fv_ = new Delegates.EvalCoord1fv_(Imports.EvalCoord1fv_);
+        public static Delegates.EvalCoord2d EvalCoord2d = new Delegates.EvalCoord2d(Imports.EvalCoord2d);
+        public static Delegates.EvalCoord2dv_ EvalCoord2dv_ = new Delegates.EvalCoord2dv_(Imports.EvalCoord2dv_);
+        public static Delegates.EvalCoord2f EvalCoord2f = new Delegates.EvalCoord2f(Imports.EvalCoord2f);
+        public static Delegates.EvalCoord2fv_ EvalCoord2fv_ = new Delegates.EvalCoord2fv_(Imports.EvalCoord2fv_);
+        public static Delegates.EvalMesh1 EvalMesh1 = new Delegates.EvalMesh1(Imports.EvalMesh1);
+        public static Delegates.EvalPoint1 EvalPoint1 = new Delegates.EvalPoint1(Imports.EvalPoint1);
+        public static Delegates.EvalMesh2 EvalMesh2 = new Delegates.EvalMesh2(Imports.EvalMesh2);
+        public static Delegates.EvalPoint2 EvalPoint2 = new Delegates.EvalPoint2(Imports.EvalPoint2);
+        public static Delegates.AlphaFunc AlphaFunc = new Delegates.AlphaFunc(Imports.AlphaFunc);
+        public static Delegates.BlendFunc BlendFunc = new Delegates.BlendFunc(Imports.BlendFunc);
+        public static Delegates.LogicOp LogicOp = new Delegates.LogicOp(Imports.LogicOp);
+        public static Delegates.StencilFunc StencilFunc = new Delegates.StencilFunc(Imports.StencilFunc);
+        public static Delegates.StencilOp StencilOp = new Delegates.StencilOp(Imports.StencilOp);
+        public static Delegates.DepthFunc DepthFunc = new Delegates.DepthFunc(Imports.DepthFunc);
+        public static Delegates.PixelZoom PixelZoom = new Delegates.PixelZoom(Imports.PixelZoom);
+        public static Delegates.PixelTransferf PixelTransferf = new Delegates.PixelTransferf(Imports.PixelTransferf);
+        public static Delegates.PixelTransferi PixelTransferi = new Delegates.PixelTransferi(Imports.PixelTransferi);
+        public static Delegates.PixelStoref PixelStoref = new Delegates.PixelStoref(Imports.PixelStoref);
+        public static Delegates.PixelStorei PixelStorei = new Delegates.PixelStorei(Imports.PixelStorei);
+        public static Delegates.PixelMapfv_ PixelMapfv_ = new Delegates.PixelMapfv_(Imports.PixelMapfv_);
+        public static Delegates.PixelMapuiv_ PixelMapuiv_ = new Delegates.PixelMapuiv_(Imports.PixelMapuiv_);
+        public static Delegates.PixelMapusv_ PixelMapusv_ = new Delegates.PixelMapusv_(Imports.PixelMapusv_);
+        public static Delegates.ReadBuffer ReadBuffer = new Delegates.ReadBuffer(Imports.ReadBuffer);
+        public static Delegates.CopyPixels CopyPixels = new Delegates.CopyPixels(Imports.CopyPixels);
+        public static Delegates.ReadPixels_ ReadPixels_ = new Delegates.ReadPixels_(Imports.ReadPixels_);
+        public static Delegates.DrawPixels_ DrawPixels_ = new Delegates.DrawPixels_(Imports.DrawPixels_);
+        public static Delegates.GetBooleanv_ GetBooleanv_ = new Delegates.GetBooleanv_(Imports.GetBooleanv_);
+        public static Delegates.GetClipPlane_ GetClipPlane_ = new Delegates.GetClipPlane_(Imports.GetClipPlane_);
+        public static Delegates.GetDoublev_ GetDoublev_ = new Delegates.GetDoublev_(Imports.GetDoublev_);
+        public static Delegates.GetError GetError = new Delegates.GetError(Imports.GetError);
+        public static Delegates.GetFloatv_ GetFloatv_ = new Delegates.GetFloatv_(Imports.GetFloatv_);
+        public static Delegates.GetIntegerv_ GetIntegerv_ = new Delegates.GetIntegerv_(Imports.GetIntegerv_);
+        public static Delegates.GetLightfv_ GetLightfv_ = new Delegates.GetLightfv_(Imports.GetLightfv_);
+        public static Delegates.GetLightiv_ GetLightiv_ = new Delegates.GetLightiv_(Imports.GetLightiv_);
+        public static Delegates.GetMapdv_ GetMapdv_ = new Delegates.GetMapdv_(Imports.GetMapdv_);
+        public static Delegates.GetMapfv_ GetMapfv_ = new Delegates.GetMapfv_(Imports.GetMapfv_);
+        public static Delegates.GetMapiv_ GetMapiv_ = new Delegates.GetMapiv_(Imports.GetMapiv_);
+        public static Delegates.GetMaterialfv_ GetMaterialfv_ = new Delegates.GetMaterialfv_(Imports.GetMaterialfv_);
+        public static Delegates.GetMaterialiv_ GetMaterialiv_ = new Delegates.GetMaterialiv_(Imports.GetMaterialiv_);
+        public static Delegates.GetPixelMapfv_ GetPixelMapfv_ = new Delegates.GetPixelMapfv_(Imports.GetPixelMapfv_);
+        public static Delegates.GetPixelMapuiv_ GetPixelMapuiv_ = new Delegates.GetPixelMapuiv_(Imports.GetPixelMapuiv_);
+        public static Delegates.GetPixelMapusv_ GetPixelMapusv_ = new Delegates.GetPixelMapusv_(Imports.GetPixelMapusv_);
+        public static Delegates.GetPolygonStipple_ GetPolygonStipple_ = new Delegates.GetPolygonStipple_(Imports.GetPolygonStipple_);
+        public static Delegates.GetString_ GetString_ = new Delegates.GetString_(Imports.GetString_);
+        public static Delegates.GetTexEnvfv_ GetTexEnvfv_ = new Delegates.GetTexEnvfv_(Imports.GetTexEnvfv_);
+        public static Delegates.GetTexEnviv_ GetTexEnviv_ = new Delegates.GetTexEnviv_(Imports.GetTexEnviv_);
+        public static Delegates.GetTexGendv_ GetTexGendv_ = new Delegates.GetTexGendv_(Imports.GetTexGendv_);
+        public static Delegates.GetTexGenfv_ GetTexGenfv_ = new Delegates.GetTexGenfv_(Imports.GetTexGenfv_);
+        public static Delegates.GetTexGeniv_ GetTexGeniv_ = new Delegates.GetTexGeniv_(Imports.GetTexGeniv_);
+        public static Delegates.GetTexImage_ GetTexImage_ = new Delegates.GetTexImage_(Imports.GetTexImage_);
+        public static Delegates.GetTexParameterfv_ GetTexParameterfv_ = new Delegates.GetTexParameterfv_(Imports.GetTexParameterfv_);
+        public static Delegates.GetTexParameteriv_ GetTexParameteriv_ = new Delegates.GetTexParameteriv_(Imports.GetTexParameteriv_);
+        public static Delegates.GetTexLevelParameterfv_ GetTexLevelParameterfv_ = new Delegates.GetTexLevelParameterfv_(Imports.GetTexLevelParameterfv_);
+        public static Delegates.GetTexLevelParameteriv_ GetTexLevelParameteriv_ = new Delegates.GetTexLevelParameteriv_(Imports.GetTexLevelParameteriv_);
+        public static Delegates.IsEnabled IsEnabled = new Delegates.IsEnabled(Imports.IsEnabled);
+        public static Delegates.IsList IsList = new Delegates.IsList(Imports.IsList);
+        public static Delegates.DepthRange DepthRange = new Delegates.DepthRange(Imports.DepthRange);
+        public static Delegates.Frustum Frustum = new Delegates.Frustum(Imports.Frustum);
+        public static Delegates.LoadIdentity LoadIdentity = new Delegates.LoadIdentity(Imports.LoadIdentity);
+        public static Delegates.LoadMatrixf_ LoadMatrixf_ = new Delegates.LoadMatrixf_(Imports.LoadMatrixf_);
+        public static Delegates.LoadMatrixd_ LoadMatrixd_ = new Delegates.LoadMatrixd_(Imports.LoadMatrixd_);
+        public static Delegates.MatrixMode MatrixMode = new Delegates.MatrixMode(Imports.MatrixMode);
+        public static Delegates.MultMatrixf_ MultMatrixf_ = new Delegates.MultMatrixf_(Imports.MultMatrixf_);
+        public static Delegates.MultMatrixd_ MultMatrixd_ = new Delegates.MultMatrixd_(Imports.MultMatrixd_);
+        public static Delegates.Ortho Ortho = new Delegates.Ortho(Imports.Ortho);
+        public static Delegates.PopMatrix PopMatrix = new Delegates.PopMatrix(Imports.PopMatrix);
+        public static Delegates.PushMatrix PushMatrix = new Delegates.PushMatrix(Imports.PushMatrix);
+        public static Delegates.Rotated Rotated = new Delegates.Rotated(Imports.Rotated);
+        public static Delegates.Rotatef Rotatef = new Delegates.Rotatef(Imports.Rotatef);
+        public static Delegates.Scaled Scaled = new Delegates.Scaled(Imports.Scaled);
+        public static Delegates.Scalef Scalef = new Delegates.Scalef(Imports.Scalef);
+        public static Delegates.Translated Translated = new Delegates.Translated(Imports.Translated);
+        public static Delegates.Translatef Translatef = new Delegates.Translatef(Imports.Translatef);
+        public static Delegates.Viewport Viewport = new Delegates.Viewport(Imports.Viewport);
+        public static Delegates.ArrayElement ArrayElement = new Delegates.ArrayElement(Imports.ArrayElement);
+        public static Delegates.ColorPointer_ ColorPointer_ = new Delegates.ColorPointer_(Imports.ColorPointer_);
+        public static Delegates.DisableClientState DisableClientState = new Delegates.DisableClientState(Imports.DisableClientState);
+        public static Delegates.DrawArrays DrawArrays = new Delegates.DrawArrays(Imports.DrawArrays);
+        public static Delegates.DrawElements_ DrawElements_ = new Delegates.DrawElements_(Imports.DrawElements_);
+        public static Delegates.EdgeFlagPointer_ EdgeFlagPointer_ = new Delegates.EdgeFlagPointer_(Imports.EdgeFlagPointer_);
+        public static Delegates.EnableClientState EnableClientState = new Delegates.EnableClientState(Imports.EnableClientState);
+        public static Delegates.GetPointerv_ GetPointerv_ = new Delegates.GetPointerv_(Imports.GetPointerv_);
+        public static Delegates.IndexPointer_ IndexPointer_ = new Delegates.IndexPointer_(Imports.IndexPointer_);
+        public static Delegates.InterleavedArrays_ InterleavedArrays_ = new Delegates.InterleavedArrays_(Imports.InterleavedArrays_);
+        public static Delegates.NormalPointer_ NormalPointer_ = new Delegates.NormalPointer_(Imports.NormalPointer_);
+        public static Delegates.TexCoordPointer_ TexCoordPointer_ = new Delegates.TexCoordPointer_(Imports.TexCoordPointer_);
+        public static Delegates.VertexPointer_ VertexPointer_ = new Delegates.VertexPointer_(Imports.VertexPointer_);
+        public static Delegates.PolygonOffset PolygonOffset = new Delegates.PolygonOffset(Imports.PolygonOffset);
+        public static Delegates.CopyTexImage1D CopyTexImage1D = new Delegates.CopyTexImage1D(Imports.CopyTexImage1D);
+        public static Delegates.CopyTexImage2D CopyTexImage2D = new Delegates.CopyTexImage2D(Imports.CopyTexImage2D);
+        public static Delegates.CopyTexSubImage1D CopyTexSubImage1D = new Delegates.CopyTexSubImage1D(Imports.CopyTexSubImage1D);
+        public static Delegates.CopyTexSubImage2D CopyTexSubImage2D = new Delegates.CopyTexSubImage2D(Imports.CopyTexSubImage2D);
+        public static Delegates.TexSubImage1D_ TexSubImage1D_ = new Delegates.TexSubImage1D_(Imports.TexSubImage1D_);
+        public static Delegates.TexSubImage2D_ TexSubImage2D_ = new Delegates.TexSubImage2D_(Imports.TexSubImage2D_);
+        public static Delegates.AreTexturesResident_ AreTexturesResident_ = new Delegates.AreTexturesResident_(Imports.AreTexturesResident_);
+        public static Delegates.BindTexture BindTexture = new Delegates.BindTexture(Imports.BindTexture);
+        public static Delegates.DeleteTextures_ DeleteTextures_ = new Delegates.DeleteTextures_(Imports.DeleteTextures_);
+        public static Delegates.GenTextures_ GenTextures_ = new Delegates.GenTextures_(Imports.GenTextures_);
+        public static Delegates.IsTexture IsTexture = new Delegates.IsTexture(Imports.IsTexture);
+        public static Delegates.PrioritizeTextures_ PrioritizeTextures_ = new Delegates.PrioritizeTextures_(Imports.PrioritizeTextures_);
+        public static Delegates.Indexub Indexub = new Delegates.Indexub(Imports.Indexub);
+        public static Delegates.Indexubv_ Indexubv_ = new Delegates.Indexubv_(Imports.Indexubv_);
+        public static Delegates.PopClientAttrib PopClientAttrib = new Delegates.PopClientAttrib(Imports.PopClientAttrib);
+        public static Delegates.PushClientAttrib PushClientAttrib = new Delegates.PushClientAttrib(Imports.PushClientAttrib);
+        public static Delegates.BlendColor BlendColor = new Delegates.BlendColor(Imports.BlendColor);
+        public static Delegates.BlendEquation BlendEquation = new Delegates.BlendEquation(Imports.BlendEquation);
+        public static Delegates.DrawRangeElements_ DrawRangeElements_ = new Delegates.DrawRangeElements_(Imports.DrawRangeElements_);
+        public static Delegates.ColorTable_ ColorTable_ = new Delegates.ColorTable_(Imports.ColorTable_);
+        public static Delegates.ColorTableParameterfv_ ColorTableParameterfv_ = new Delegates.ColorTableParameterfv_(Imports.ColorTableParameterfv_);
+        public static Delegates.ColorTableParameteriv_ ColorTableParameteriv_ = new Delegates.ColorTableParameteriv_(Imports.ColorTableParameteriv_);
+        public static Delegates.CopyColorTable CopyColorTable = new Delegates.CopyColorTable(Imports.CopyColorTable);
+        public static Delegates.GetColorTable_ GetColorTable_ = new Delegates.GetColorTable_(Imports.GetColorTable_);
+        public static Delegates.GetColorTableParameterfv_ GetColorTableParameterfv_ = new Delegates.GetColorTableParameterfv_(Imports.GetColorTableParameterfv_);
+        public static Delegates.GetColorTableParameteriv_ GetColorTableParameteriv_ = new Delegates.GetColorTableParameteriv_(Imports.GetColorTableParameteriv_);
+        public static Delegates.ColorSubTable_ ColorSubTable_ = new Delegates.ColorSubTable_(Imports.ColorSubTable_);
+        public static Delegates.CopyColorSubTable CopyColorSubTable = new Delegates.CopyColorSubTable(Imports.CopyColorSubTable);
+        public static Delegates.ConvolutionFilter1D_ ConvolutionFilter1D_ = new Delegates.ConvolutionFilter1D_(Imports.ConvolutionFilter1D_);
+        public static Delegates.ConvolutionFilter2D_ ConvolutionFilter2D_ = new Delegates.ConvolutionFilter2D_(Imports.ConvolutionFilter2D_);
+        public static Delegates.ConvolutionParameterf ConvolutionParameterf = new Delegates.ConvolutionParameterf(Imports.ConvolutionParameterf);
+        public static Delegates.ConvolutionParameterfv_ ConvolutionParameterfv_ = new Delegates.ConvolutionParameterfv_(Imports.ConvolutionParameterfv_);
+        public static Delegates.ConvolutionParameteri ConvolutionParameteri = new Delegates.ConvolutionParameteri(Imports.ConvolutionParameteri);
+        public static Delegates.ConvolutionParameteriv_ ConvolutionParameteriv_ = new Delegates.ConvolutionParameteriv_(Imports.ConvolutionParameteriv_);
+        public static Delegates.CopyConvolutionFilter1D CopyConvolutionFilter1D = new Delegates.CopyConvolutionFilter1D(Imports.CopyConvolutionFilter1D);
+        public static Delegates.CopyConvolutionFilter2D CopyConvolutionFilter2D = new Delegates.CopyConvolutionFilter2D(Imports.CopyConvolutionFilter2D);
+        public static Delegates.GetConvolutionFilter_ GetConvolutionFilter_ = new Delegates.GetConvolutionFilter_(Imports.GetConvolutionFilter_);
+        public static Delegates.GetConvolutionParameterfv_ GetConvolutionParameterfv_ = new Delegates.GetConvolutionParameterfv_(Imports.GetConvolutionParameterfv_);
+        public static Delegates.GetConvolutionParameteriv_ GetConvolutionParameteriv_ = new Delegates.GetConvolutionParameteriv_(Imports.GetConvolutionParameteriv_);
+        public static Delegates.GetSeparableFilter_ GetSeparableFilter_ = new Delegates.GetSeparableFilter_(Imports.GetSeparableFilter_);
+        public static Delegates.SeparableFilter2D_ SeparableFilter2D_ = new Delegates.SeparableFilter2D_(Imports.SeparableFilter2D_);
+        public static Delegates.GetHistogram_ GetHistogram_ = new Delegates.GetHistogram_(Imports.GetHistogram_);
+        public static Delegates.GetHistogramParameterfv_ GetHistogramParameterfv_ = new Delegates.GetHistogramParameterfv_(Imports.GetHistogramParameterfv_);
+        public static Delegates.GetHistogramParameteriv_ GetHistogramParameteriv_ = new Delegates.GetHistogramParameteriv_(Imports.GetHistogramParameteriv_);
+        public static Delegates.GetMinmax_ GetMinmax_ = new Delegates.GetMinmax_(Imports.GetMinmax_);
+        public static Delegates.GetMinmaxParameterfv_ GetMinmaxParameterfv_ = new Delegates.GetMinmaxParameterfv_(Imports.GetMinmaxParameterfv_);
+        public static Delegates.GetMinmaxParameteriv_ GetMinmaxParameteriv_ = new Delegates.GetMinmaxParameteriv_(Imports.GetMinmaxParameteriv_);
+        public static Delegates.Histogram Histogram = new Delegates.Histogram(Imports.Histogram);
+        public static Delegates.Minmax Minmax = new Delegates.Minmax(Imports.Minmax);
+        public static Delegates.ResetHistogram ResetHistogram = new Delegates.ResetHistogram(Imports.ResetHistogram);
+        public static Delegates.ResetMinmax ResetMinmax = new Delegates.ResetMinmax(Imports.ResetMinmax);
+        public static Delegates.TexImage3D_ TexImage3D_ = new Delegates.TexImage3D_(Imports.TexImage3D_);
+        public static Delegates.TexSubImage3D_ TexSubImage3D_ = new Delegates.TexSubImage3D_(Imports.TexSubImage3D_);
+        public static Delegates.CopyTexSubImage3D CopyTexSubImage3D = new Delegates.CopyTexSubImage3D(Imports.CopyTexSubImage3D);
+        public static Delegates.ActiveTexture ActiveTexture = new Delegates.ActiveTexture(Imports.ActiveTexture);
+        public static Delegates.ClientActiveTexture ClientActiveTexture = new Delegates.ClientActiveTexture(Imports.ClientActiveTexture);
+        public static Delegates.MultiTexCoord1d MultiTexCoord1d = new Delegates.MultiTexCoord1d(Imports.MultiTexCoord1d);
+        public static Delegates.MultiTexCoord1dv_ MultiTexCoord1dv_ = new Delegates.MultiTexCoord1dv_(Imports.MultiTexCoord1dv_);
+        public static Delegates.MultiTexCoord1f MultiTexCoord1f = new Delegates.MultiTexCoord1f(Imports.MultiTexCoord1f);
+        public static Delegates.MultiTexCoord1fv_ MultiTexCoord1fv_ = new Delegates.MultiTexCoord1fv_(Imports.MultiTexCoord1fv_);
+        public static Delegates.MultiTexCoord1i MultiTexCoord1i = new Delegates.MultiTexCoord1i(Imports.MultiTexCoord1i);
+        public static Delegates.MultiTexCoord1iv_ MultiTexCoord1iv_ = new Delegates.MultiTexCoord1iv_(Imports.MultiTexCoord1iv_);
+        public static Delegates.MultiTexCoord1s MultiTexCoord1s = new Delegates.MultiTexCoord1s(Imports.MultiTexCoord1s);
+        public static Delegates.MultiTexCoord1sv_ MultiTexCoord1sv_ = new Delegates.MultiTexCoord1sv_(Imports.MultiTexCoord1sv_);
+        public static Delegates.MultiTexCoord2d MultiTexCoord2d = new Delegates.MultiTexCoord2d(Imports.MultiTexCoord2d);
+        public static Delegates.MultiTexCoord2dv_ MultiTexCoord2dv_ = new Delegates.MultiTexCoord2dv_(Imports.MultiTexCoord2dv_);
+        public static Delegates.MultiTexCoord2f MultiTexCoord2f = new Delegates.MultiTexCoord2f(Imports.MultiTexCoord2f);
+        public static Delegates.MultiTexCoord2fv_ MultiTexCoord2fv_ = new Delegates.MultiTexCoord2fv_(Imports.MultiTexCoord2fv_);
+        public static Delegates.MultiTexCoord2i MultiTexCoord2i = new Delegates.MultiTexCoord2i(Imports.MultiTexCoord2i);
+        public static Delegates.MultiTexCoord2iv_ MultiTexCoord2iv_ = new Delegates.MultiTexCoord2iv_(Imports.MultiTexCoord2iv_);
+        public static Delegates.MultiTexCoord2s MultiTexCoord2s = new Delegates.MultiTexCoord2s(Imports.MultiTexCoord2s);
+        public static Delegates.MultiTexCoord2sv_ MultiTexCoord2sv_ = new Delegates.MultiTexCoord2sv_(Imports.MultiTexCoord2sv_);
+        public static Delegates.MultiTexCoord3d MultiTexCoord3d = new Delegates.MultiTexCoord3d(Imports.MultiTexCoord3d);
+        public static Delegates.MultiTexCoord3dv_ MultiTexCoord3dv_ = new Delegates.MultiTexCoord3dv_(Imports.MultiTexCoord3dv_);
+        public static Delegates.MultiTexCoord3f MultiTexCoord3f = new Delegates.MultiTexCoord3f(Imports.MultiTexCoord3f);
+        public static Delegates.MultiTexCoord3fv_ MultiTexCoord3fv_ = new Delegates.MultiTexCoord3fv_(Imports.MultiTexCoord3fv_);
+        public static Delegates.MultiTexCoord3i MultiTexCoord3i = new Delegates.MultiTexCoord3i(Imports.MultiTexCoord3i);
+        public static Delegates.MultiTexCoord3iv_ MultiTexCoord3iv_ = new Delegates.MultiTexCoord3iv_(Imports.MultiTexCoord3iv_);
+        public static Delegates.MultiTexCoord3s MultiTexCoord3s = new Delegates.MultiTexCoord3s(Imports.MultiTexCoord3s);
+        public static Delegates.MultiTexCoord3sv_ MultiTexCoord3sv_ = new Delegates.MultiTexCoord3sv_(Imports.MultiTexCoord3sv_);
+        public static Delegates.MultiTexCoord4d MultiTexCoord4d = new Delegates.MultiTexCoord4d(Imports.MultiTexCoord4d);
+        public static Delegates.MultiTexCoord4dv_ MultiTexCoord4dv_ = new Delegates.MultiTexCoord4dv_(Imports.MultiTexCoord4dv_);
+        public static Delegates.MultiTexCoord4f MultiTexCoord4f = new Delegates.MultiTexCoord4f(Imports.MultiTexCoord4f);
+        public static Delegates.MultiTexCoord4fv_ MultiTexCoord4fv_ = new Delegates.MultiTexCoord4fv_(Imports.MultiTexCoord4fv_);
+        public static Delegates.MultiTexCoord4i MultiTexCoord4i = new Delegates.MultiTexCoord4i(Imports.MultiTexCoord4i);
+        public static Delegates.MultiTexCoord4iv_ MultiTexCoord4iv_ = new Delegates.MultiTexCoord4iv_(Imports.MultiTexCoord4iv_);
+        public static Delegates.MultiTexCoord4s MultiTexCoord4s = new Delegates.MultiTexCoord4s(Imports.MultiTexCoord4s);
+        public static Delegates.MultiTexCoord4sv_ MultiTexCoord4sv_ = new Delegates.MultiTexCoord4sv_(Imports.MultiTexCoord4sv_);
+        public static Delegates.LoadTransposeMatrixf_ LoadTransposeMatrixf_ = new Delegates.LoadTransposeMatrixf_(Imports.LoadTransposeMatrixf_);
+        public static Delegates.LoadTransposeMatrixd_ LoadTransposeMatrixd_ = new Delegates.LoadTransposeMatrixd_(Imports.LoadTransposeMatrixd_);
+        public static Delegates.MultTransposeMatrixf_ MultTransposeMatrixf_ = new Delegates.MultTransposeMatrixf_(Imports.MultTransposeMatrixf_);
+        public static Delegates.MultTransposeMatrixd_ MultTransposeMatrixd_ = new Delegates.MultTransposeMatrixd_(Imports.MultTransposeMatrixd_);
+        public static Delegates.SampleCoverage SampleCoverage = new Delegates.SampleCoverage(Imports.SampleCoverage);
+        public static Delegates.CompressedTexImage3D_ CompressedTexImage3D_ = new Delegates.CompressedTexImage3D_(Imports.CompressedTexImage3D_);
+        public static Delegates.CompressedTexImage2D_ CompressedTexImage2D_ = new Delegates.CompressedTexImage2D_(Imports.CompressedTexImage2D_);
+        public static Delegates.CompressedTexImage1D_ CompressedTexImage1D_ = new Delegates.CompressedTexImage1D_(Imports.CompressedTexImage1D_);
+        public static Delegates.CompressedTexSubImage3D_ CompressedTexSubImage3D_ = new Delegates.CompressedTexSubImage3D_(Imports.CompressedTexSubImage3D_);
+        public static Delegates.CompressedTexSubImage2D_ CompressedTexSubImage2D_ = new Delegates.CompressedTexSubImage2D_(Imports.CompressedTexSubImage2D_);
+        public static Delegates.CompressedTexSubImage1D_ CompressedTexSubImage1D_ = new Delegates.CompressedTexSubImage1D_(Imports.CompressedTexSubImage1D_);
+        public static Delegates.GetCompressedTexImage_ GetCompressedTexImage_ = new Delegates.GetCompressedTexImage_(Imports.GetCompressedTexImage_);
+        public static Delegates.BlendFuncSeparate BlendFuncSeparate = new Delegates.BlendFuncSeparate(Imports.BlendFuncSeparate);
+        public static Delegates.FogCoordf FogCoordf = new Delegates.FogCoordf(Imports.FogCoordf);
+        public static Delegates.FogCoordfv_ FogCoordfv_ = new Delegates.FogCoordfv_(Imports.FogCoordfv_);
+        public static Delegates.FogCoordd FogCoordd = new Delegates.FogCoordd(Imports.FogCoordd);
+        public static Delegates.FogCoorddv_ FogCoorddv_ = new Delegates.FogCoorddv_(Imports.FogCoorddv_);
+        public static Delegates.FogCoordPointer_ FogCoordPointer_ = new Delegates.FogCoordPointer_(Imports.FogCoordPointer_);
+        public static Delegates.MultiDrawArrays_ MultiDrawArrays_ = new Delegates.MultiDrawArrays_(Imports.MultiDrawArrays_);
+        public static Delegates.MultiDrawElements_ MultiDrawElements_ = new Delegates.MultiDrawElements_(Imports.MultiDrawElements_);
+        public static Delegates.PointParameterf PointParameterf = new Delegates.PointParameterf(Imports.PointParameterf);
+        public static Delegates.PointParameterfv_ PointParameterfv_ = new Delegates.PointParameterfv_(Imports.PointParameterfv_);
+        public static Delegates.PointParameteri PointParameteri = new Delegates.PointParameteri(Imports.PointParameteri);
+        public static Delegates.PointParameteriv_ PointParameteriv_ = new Delegates.PointParameteriv_(Imports.PointParameteriv_);
+        public static Delegates.SecondaryColor3b SecondaryColor3b = new Delegates.SecondaryColor3b(Imports.SecondaryColor3b);
+        public static Delegates.SecondaryColor3bv_ SecondaryColor3bv_ = new Delegates.SecondaryColor3bv_(Imports.SecondaryColor3bv_);
+        public static Delegates.SecondaryColor3d SecondaryColor3d = new Delegates.SecondaryColor3d(Imports.SecondaryColor3d);
+        public static Delegates.SecondaryColor3dv_ SecondaryColor3dv_ = new Delegates.SecondaryColor3dv_(Imports.SecondaryColor3dv_);
+        public static Delegates.SecondaryColor3f SecondaryColor3f = new Delegates.SecondaryColor3f(Imports.SecondaryColor3f);
+        public static Delegates.SecondaryColor3fv_ SecondaryColor3fv_ = new Delegates.SecondaryColor3fv_(Imports.SecondaryColor3fv_);
+        public static Delegates.SecondaryColor3i SecondaryColor3i = new Delegates.SecondaryColor3i(Imports.SecondaryColor3i);
+        public static Delegates.SecondaryColor3iv_ SecondaryColor3iv_ = new Delegates.SecondaryColor3iv_(Imports.SecondaryColor3iv_);
+        public static Delegates.SecondaryColor3s SecondaryColor3s = new Delegates.SecondaryColor3s(Imports.SecondaryColor3s);
+        public static Delegates.SecondaryColor3sv_ SecondaryColor3sv_ = new Delegates.SecondaryColor3sv_(Imports.SecondaryColor3sv_);
+        public static Delegates.SecondaryColor3ub SecondaryColor3ub = new Delegates.SecondaryColor3ub(Imports.SecondaryColor3ub);
+        public static Delegates.SecondaryColor3ubv_ SecondaryColor3ubv_ = new Delegates.SecondaryColor3ubv_(Imports.SecondaryColor3ubv_);
+        public static Delegates.SecondaryColor3ui SecondaryColor3ui = new Delegates.SecondaryColor3ui(Imports.SecondaryColor3ui);
+        public static Delegates.SecondaryColor3uiv_ SecondaryColor3uiv_ = new Delegates.SecondaryColor3uiv_(Imports.SecondaryColor3uiv_);
+        public static Delegates.SecondaryColor3us SecondaryColor3us = new Delegates.SecondaryColor3us(Imports.SecondaryColor3us);
+        public static Delegates.SecondaryColor3usv_ SecondaryColor3usv_ = new Delegates.SecondaryColor3usv_(Imports.SecondaryColor3usv_);
+        public static Delegates.SecondaryColorPointer_ SecondaryColorPointer_ = new Delegates.SecondaryColorPointer_(Imports.SecondaryColorPointer_);
+        public static Delegates.WindowPos2d WindowPos2d = new Delegates.WindowPos2d(Imports.WindowPos2d);
+        public static Delegates.WindowPos2dv_ WindowPos2dv_ = new Delegates.WindowPos2dv_(Imports.WindowPos2dv_);
+        public static Delegates.WindowPos2f WindowPos2f = new Delegates.WindowPos2f(Imports.WindowPos2f);
+        public static Delegates.WindowPos2fv_ WindowPos2fv_ = new Delegates.WindowPos2fv_(Imports.WindowPos2fv_);
+        public static Delegates.WindowPos2i WindowPos2i = new Delegates.WindowPos2i(Imports.WindowPos2i);
+        public static Delegates.WindowPos2iv_ WindowPos2iv_ = new Delegates.WindowPos2iv_(Imports.WindowPos2iv_);
+        public static Delegates.WindowPos2s WindowPos2s = new Delegates.WindowPos2s(Imports.WindowPos2s);
+        public static Delegates.WindowPos2sv_ WindowPos2sv_ = new Delegates.WindowPos2sv_(Imports.WindowPos2sv_);
+        public static Delegates.WindowPos3d WindowPos3d = new Delegates.WindowPos3d(Imports.WindowPos3d);
+        public static Delegates.WindowPos3dv_ WindowPos3dv_ = new Delegates.WindowPos3dv_(Imports.WindowPos3dv_);
+        public static Delegates.WindowPos3f WindowPos3f = new Delegates.WindowPos3f(Imports.WindowPos3f);
+        public static Delegates.WindowPos3fv_ WindowPos3fv_ = new Delegates.WindowPos3fv_(Imports.WindowPos3fv_);
+        public static Delegates.WindowPos3i WindowPos3i = new Delegates.WindowPos3i(Imports.WindowPos3i);
+        public static Delegates.WindowPos3iv_ WindowPos3iv_ = new Delegates.WindowPos3iv_(Imports.WindowPos3iv_);
+        public static Delegates.WindowPos3s WindowPos3s = new Delegates.WindowPos3s(Imports.WindowPos3s);
+        public static Delegates.WindowPos3sv_ WindowPos3sv_ = new Delegates.WindowPos3sv_(Imports.WindowPos3sv_);
+        public static Delegates.GenQueries_ GenQueries_ = new Delegates.GenQueries_(Imports.GenQueries_);
+        public static Delegates.DeleteQueries_ DeleteQueries_ = new Delegates.DeleteQueries_(Imports.DeleteQueries_);
+        public static Delegates.IsQuery IsQuery = new Delegates.IsQuery(Imports.IsQuery);
+        public static Delegates.BeginQuery BeginQuery = new Delegates.BeginQuery(Imports.BeginQuery);
+        public static Delegates.EndQuery EndQuery = new Delegates.EndQuery(Imports.EndQuery);
+        public static Delegates.GetQueryiv_ GetQueryiv_ = new Delegates.GetQueryiv_(Imports.GetQueryiv_);
+        public static Delegates.GetQueryObjectiv_ GetQueryObjectiv_ = new Delegates.GetQueryObjectiv_(Imports.GetQueryObjectiv_);
+        public static Delegates.GetQueryObjectuiv_ GetQueryObjectuiv_ = new Delegates.GetQueryObjectuiv_(Imports.GetQueryObjectuiv_);
+        public static Delegates.BindBuffer BindBuffer = new Delegates.BindBuffer(Imports.BindBuffer);
+        public static Delegates.DeleteBuffers_ DeleteBuffers_ = new Delegates.DeleteBuffers_(Imports.DeleteBuffers_);
+        public static Delegates.GenBuffers_ GenBuffers_ = new Delegates.GenBuffers_(Imports.GenBuffers_);
+        public static Delegates.IsBuffer IsBuffer = new Delegates.IsBuffer(Imports.IsBuffer);
+        public static Delegates.BufferData_ BufferData_ = new Delegates.BufferData_(Imports.BufferData_);
+        public static Delegates.BufferSubData_ BufferSubData_ = new Delegates.BufferSubData_(Imports.BufferSubData_);
+        public static Delegates.GetBufferSubData_ GetBufferSubData_ = new Delegates.GetBufferSubData_(Imports.GetBufferSubData_);
+        public static Delegates.MapBuffer MapBuffer = new Delegates.MapBuffer(Imports.MapBuffer);
+        public static Delegates.UnmapBuffer UnmapBuffer = new Delegates.UnmapBuffer(Imports.UnmapBuffer);
+        public static Delegates.GetBufferParameteriv_ GetBufferParameteriv_ = new Delegates.GetBufferParameteriv_(Imports.GetBufferParameteriv_);
+        public static Delegates.GetBufferPointerv_ GetBufferPointerv_ = new Delegates.GetBufferPointerv_(Imports.GetBufferPointerv_);
+        public static Delegates.BlendEquationSeparate BlendEquationSeparate = new Delegates.BlendEquationSeparate(Imports.BlendEquationSeparate);
+        public static Delegates.DrawBuffers_ DrawBuffers_ = new Delegates.DrawBuffers_(Imports.DrawBuffers_);
+        public static Delegates.StencilOpSeparate StencilOpSeparate = new Delegates.StencilOpSeparate(Imports.StencilOpSeparate);
+        public static Delegates.StencilFuncSeparate StencilFuncSeparate = new Delegates.StencilFuncSeparate(Imports.StencilFuncSeparate);
+        public static Delegates.StencilMaskSeparate StencilMaskSeparate = new Delegates.StencilMaskSeparate(Imports.StencilMaskSeparate);
+        public static Delegates.AttachShader AttachShader = new Delegates.AttachShader(Imports.AttachShader);
+        public static Delegates.BindAttribLocation BindAttribLocation = new Delegates.BindAttribLocation(Imports.BindAttribLocation);
+        public static Delegates.CompileShader CompileShader = new Delegates.CompileShader(Imports.CompileShader);
+        public static Delegates.CreateProgram CreateProgram = new Delegates.CreateProgram(Imports.CreateProgram);
+        public static Delegates.CreateShader CreateShader = new Delegates.CreateShader(Imports.CreateShader);
+        public static Delegates.DeleteProgram DeleteProgram = new Delegates.DeleteProgram(Imports.DeleteProgram);
+        public static Delegates.DeleteShader DeleteShader = new Delegates.DeleteShader(Imports.DeleteShader);
+        public static Delegates.DetachShader DetachShader = new Delegates.DetachShader(Imports.DetachShader);
+        public static Delegates.DisableVertexAttribArray DisableVertexAttribArray = new Delegates.DisableVertexAttribArray(Imports.DisableVertexAttribArray);
+        public static Delegates.EnableVertexAttribArray EnableVertexAttribArray = new Delegates.EnableVertexAttribArray(Imports.EnableVertexAttribArray);
+        public static Delegates.GetActiveAttrib_ GetActiveAttrib_ = new Delegates.GetActiveAttrib_(Imports.GetActiveAttrib_);
+        public static Delegates.GetActiveUniform_ GetActiveUniform_ = new Delegates.GetActiveUniform_(Imports.GetActiveUniform_);
+        public static Delegates.GetAttachedShaders_ GetAttachedShaders_ = new Delegates.GetAttachedShaders_(Imports.GetAttachedShaders_);
+        public static Delegates.GetAttribLocation GetAttribLocation = new Delegates.GetAttribLocation(Imports.GetAttribLocation);
+        public static Delegates.GetProgramiv_ GetProgramiv_ = new Delegates.GetProgramiv_(Imports.GetProgramiv_);
+        public static Delegates.GetProgramInfoLog_ GetProgramInfoLog_ = new Delegates.GetProgramInfoLog_(Imports.GetProgramInfoLog_);
+        public static Delegates.GetShaderiv_ GetShaderiv_ = new Delegates.GetShaderiv_(Imports.GetShaderiv_);
+        public static Delegates.GetShaderInfoLog_ GetShaderInfoLog_ = new Delegates.GetShaderInfoLog_(Imports.GetShaderInfoLog_);
+        public static Delegates.GetShaderSource_ GetShaderSource_ = new Delegates.GetShaderSource_(Imports.GetShaderSource_);
+        public static Delegates.GetUniformLocation GetUniformLocation = new Delegates.GetUniformLocation(Imports.GetUniformLocation);
+        public static Delegates.GetUniformfv_ GetUniformfv_ = new Delegates.GetUniformfv_(Imports.GetUniformfv_);
+        public static Delegates.GetUniformiv_ GetUniformiv_ = new Delegates.GetUniformiv_(Imports.GetUniformiv_);
+        public static Delegates.GetVertexAttribdv_ GetVertexAttribdv_ = new Delegates.GetVertexAttribdv_(Imports.GetVertexAttribdv_);
+        public static Delegates.GetVertexAttribfv_ GetVertexAttribfv_ = new Delegates.GetVertexAttribfv_(Imports.GetVertexAttribfv_);
+        public static Delegates.GetVertexAttribiv_ GetVertexAttribiv_ = new Delegates.GetVertexAttribiv_(Imports.GetVertexAttribiv_);
+        public static Delegates.GetVertexAttribPointerv_ GetVertexAttribPointerv_ = new Delegates.GetVertexAttribPointerv_(Imports.GetVertexAttribPointerv_);
+        public static Delegates.IsProgram IsProgram = new Delegates.IsProgram(Imports.IsProgram);
+        public static Delegates.IsShader IsShader = new Delegates.IsShader(Imports.IsShader);
+        public static Delegates.LinkProgram LinkProgram = new Delegates.LinkProgram(Imports.LinkProgram);
+        public static Delegates.ShaderSource_ ShaderSource_ = new Delegates.ShaderSource_(Imports.ShaderSource_);
+        public static Delegates.UseProgram UseProgram = new Delegates.UseProgram(Imports.UseProgram);
+        public static Delegates.Uniform1f Uniform1f = new Delegates.Uniform1f(Imports.Uniform1f);
+        public static Delegates.Uniform2f Uniform2f = new Delegates.Uniform2f(Imports.Uniform2f);
+        public static Delegates.Uniform3f Uniform3f = new Delegates.Uniform3f(Imports.Uniform3f);
+        public static Delegates.Uniform4f Uniform4f = new Delegates.Uniform4f(Imports.Uniform4f);
+        public static Delegates.Uniform1i Uniform1i = new Delegates.Uniform1i(Imports.Uniform1i);
+        public static Delegates.Uniform2i Uniform2i = new Delegates.Uniform2i(Imports.Uniform2i);
+        public static Delegates.Uniform3i Uniform3i = new Delegates.Uniform3i(Imports.Uniform3i);
+        public static Delegates.Uniform4i Uniform4i = new Delegates.Uniform4i(Imports.Uniform4i);
+        public static Delegates.Uniform1fv_ Uniform1fv_ = new Delegates.Uniform1fv_(Imports.Uniform1fv_);
+        public static Delegates.Uniform2fv_ Uniform2fv_ = new Delegates.Uniform2fv_(Imports.Uniform2fv_);
+        public static Delegates.Uniform3fv_ Uniform3fv_ = new Delegates.Uniform3fv_(Imports.Uniform3fv_);
+        public static Delegates.Uniform4fv_ Uniform4fv_ = new Delegates.Uniform4fv_(Imports.Uniform4fv_);
+        public static Delegates.Uniform1iv_ Uniform1iv_ = new Delegates.Uniform1iv_(Imports.Uniform1iv_);
+        public static Delegates.Uniform2iv_ Uniform2iv_ = new Delegates.Uniform2iv_(Imports.Uniform2iv_);
+        public static Delegates.Uniform3iv_ Uniform3iv_ = new Delegates.Uniform3iv_(Imports.Uniform3iv_);
+        public static Delegates.Uniform4iv_ Uniform4iv_ = new Delegates.Uniform4iv_(Imports.Uniform4iv_);
+        public static Delegates.UniformMatrix2fv_ UniformMatrix2fv_ = new Delegates.UniformMatrix2fv_(Imports.UniformMatrix2fv_);
+        public static Delegates.UniformMatrix3fv_ UniformMatrix3fv_ = new Delegates.UniformMatrix3fv_(Imports.UniformMatrix3fv_);
+        public static Delegates.UniformMatrix4fv_ UniformMatrix4fv_ = new Delegates.UniformMatrix4fv_(Imports.UniformMatrix4fv_);
+        public static Delegates.ValidateProgram ValidateProgram = new Delegates.ValidateProgram(Imports.ValidateProgram);
+        public static Delegates.VertexAttrib1d VertexAttrib1d = new Delegates.VertexAttrib1d(Imports.VertexAttrib1d);
+        public static Delegates.VertexAttrib1dv_ VertexAttrib1dv_ = new Delegates.VertexAttrib1dv_(Imports.VertexAttrib1dv_);
+        public static Delegates.VertexAttrib1f VertexAttrib1f = new Delegates.VertexAttrib1f(Imports.VertexAttrib1f);
+        public static Delegates.VertexAttrib1fv_ VertexAttrib1fv_ = new Delegates.VertexAttrib1fv_(Imports.VertexAttrib1fv_);
+        public static Delegates.VertexAttrib1s VertexAttrib1s = new Delegates.VertexAttrib1s(Imports.VertexAttrib1s);
+        public static Delegates.VertexAttrib1sv_ VertexAttrib1sv_ = new Delegates.VertexAttrib1sv_(Imports.VertexAttrib1sv_);
+        public static Delegates.VertexAttrib2d VertexAttrib2d = new Delegates.VertexAttrib2d(Imports.VertexAttrib2d);
+        public static Delegates.VertexAttrib2dv_ VertexAttrib2dv_ = new Delegates.VertexAttrib2dv_(Imports.VertexAttrib2dv_);
+        public static Delegates.VertexAttrib2f VertexAttrib2f = new Delegates.VertexAttrib2f(Imports.VertexAttrib2f);
+        public static Delegates.VertexAttrib2fv_ VertexAttrib2fv_ = new Delegates.VertexAttrib2fv_(Imports.VertexAttrib2fv_);
+        public static Delegates.VertexAttrib2s VertexAttrib2s = new Delegates.VertexAttrib2s(Imports.VertexAttrib2s);
+        public static Delegates.VertexAttrib2sv_ VertexAttrib2sv_ = new Delegates.VertexAttrib2sv_(Imports.VertexAttrib2sv_);
+        public static Delegates.VertexAttrib3d VertexAttrib3d = new Delegates.VertexAttrib3d(Imports.VertexAttrib3d);
+        public static Delegates.VertexAttrib3dv_ VertexAttrib3dv_ = new Delegates.VertexAttrib3dv_(Imports.VertexAttrib3dv_);
+        public static Delegates.VertexAttrib3f VertexAttrib3f = new Delegates.VertexAttrib3f(Imports.VertexAttrib3f);
+        public static Delegates.VertexAttrib3fv_ VertexAttrib3fv_ = new Delegates.VertexAttrib3fv_(Imports.VertexAttrib3fv_);
+        public static Delegates.VertexAttrib3s VertexAttrib3s = new Delegates.VertexAttrib3s(Imports.VertexAttrib3s);
+        public static Delegates.VertexAttrib3sv_ VertexAttrib3sv_ = new Delegates.VertexAttrib3sv_(Imports.VertexAttrib3sv_);
+        public static Delegates.VertexAttrib4Nbv_ VertexAttrib4Nbv_ = new Delegates.VertexAttrib4Nbv_(Imports.VertexAttrib4Nbv_);
+        public static Delegates.VertexAttrib4Niv_ VertexAttrib4Niv_ = new Delegates.VertexAttrib4Niv_(Imports.VertexAttrib4Niv_);
+        public static Delegates.VertexAttrib4Nsv_ VertexAttrib4Nsv_ = new Delegates.VertexAttrib4Nsv_(Imports.VertexAttrib4Nsv_);
+        public static Delegates.VertexAttrib4Nub VertexAttrib4Nub = new Delegates.VertexAttrib4Nub(Imports.VertexAttrib4Nub);
+        public static Delegates.VertexAttrib4Nubv_ VertexAttrib4Nubv_ = new Delegates.VertexAttrib4Nubv_(Imports.VertexAttrib4Nubv_);
+        public static Delegates.VertexAttrib4Nuiv_ VertexAttrib4Nuiv_ = new Delegates.VertexAttrib4Nuiv_(Imports.VertexAttrib4Nuiv_);
+        public static Delegates.VertexAttrib4Nusv_ VertexAttrib4Nusv_ = new Delegates.VertexAttrib4Nusv_(Imports.VertexAttrib4Nusv_);
+        public static Delegates.VertexAttrib4bv_ VertexAttrib4bv_ = new Delegates.VertexAttrib4bv_(Imports.VertexAttrib4bv_);
+        public static Delegates.VertexAttrib4d VertexAttrib4d = new Delegates.VertexAttrib4d(Imports.VertexAttrib4d);
+        public static Delegates.VertexAttrib4dv_ VertexAttrib4dv_ = new Delegates.VertexAttrib4dv_(Imports.VertexAttrib4dv_);
+        public static Delegates.VertexAttrib4f VertexAttrib4f = new Delegates.VertexAttrib4f(Imports.VertexAttrib4f);
+        public static Delegates.VertexAttrib4fv_ VertexAttrib4fv_ = new Delegates.VertexAttrib4fv_(Imports.VertexAttrib4fv_);
+        public static Delegates.VertexAttrib4iv_ VertexAttrib4iv_ = new Delegates.VertexAttrib4iv_(Imports.VertexAttrib4iv_);
+        public static Delegates.VertexAttrib4s VertexAttrib4s = new Delegates.VertexAttrib4s(Imports.VertexAttrib4s);
+        public static Delegates.VertexAttrib4sv_ VertexAttrib4sv_ = new Delegates.VertexAttrib4sv_(Imports.VertexAttrib4sv_);
+        public static Delegates.VertexAttrib4ubv_ VertexAttrib4ubv_ = new Delegates.VertexAttrib4ubv_(Imports.VertexAttrib4ubv_);
+        public static Delegates.VertexAttrib4uiv_ VertexAttrib4uiv_ = new Delegates.VertexAttrib4uiv_(Imports.VertexAttrib4uiv_);
+        public static Delegates.VertexAttrib4usv_ VertexAttrib4usv_ = new Delegates.VertexAttrib4usv_(Imports.VertexAttrib4usv_);
+        public static Delegates.VertexAttribPointer_ VertexAttribPointer_ = new Delegates.VertexAttribPointer_(Imports.VertexAttribPointer_);
+        public static Delegates.UniformMatrix2x3fv_ UniformMatrix2x3fv_ = new Delegates.UniformMatrix2x3fv_(Imports.UniformMatrix2x3fv_);
+        public static Delegates.UniformMatrix3x2fv_ UniformMatrix3x2fv_ = new Delegates.UniformMatrix3x2fv_(Imports.UniformMatrix3x2fv_);
+        public static Delegates.UniformMatrix2x4fv_ UniformMatrix2x4fv_ = new Delegates.UniformMatrix2x4fv_(Imports.UniformMatrix2x4fv_);
+        public static Delegates.UniformMatrix4x2fv_ UniformMatrix4x2fv_ = new Delegates.UniformMatrix4x2fv_(Imports.UniformMatrix4x2fv_);
+        public static Delegates.UniformMatrix3x4fv_ UniformMatrix3x4fv_ = new Delegates.UniformMatrix3x4fv_(Imports.UniformMatrix3x4fv_);
+        public static Delegates.UniformMatrix4x3fv_ UniformMatrix4x3fv_ = new Delegates.UniformMatrix4x3fv_(Imports.UniformMatrix4x3fv_);
 
         #endregion
 
@@ -10128,10 +3237,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region EdgeFlagv(GLboolean[] flag)
+        #region EdgeFlagv(Enums.Boolean[] flag)
 
         public static
-        void EdgeFlagv(GLboolean[] flag)
+        void EdgeFlagv(Enums.Boolean[] flag)
         {
             GCHandle h0 = GCHandle.Alloc(flag, GCHandleType.Pinned);
             try
@@ -14578,10 +7687,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region GetBooleanv(Enums.GetPName pname, GLboolean[] parameters)
+        #region GetBooleanv(Enums.GetPName pname, Enums.Boolean[] parameters)
 
         public static
-        void GetBooleanv(Enums.GetPName pname, GLboolean[] parameters)
+        void GetBooleanv(Enums.GetPName pname, Enums.Boolean[] parameters)
         {
             GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
             try
@@ -16276,10 +9385,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region AreTexturesResident(GLsizei n, IntPtr textures, GLboolean[] residences)
+        #region AreTexturesResident(GLsizei n, IntPtr textures, Enums.Boolean[] residences)
 
         public static
-        GLboolean AreTexturesResident(GLsizei n, IntPtr textures, GLboolean[] residences)
+        GLboolean AreTexturesResident(GLsizei n, IntPtr textures, Enums.Boolean[] residences)
         {
             GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
             try
@@ -16332,10 +9441,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region AreTexturesResident(GLsizei n, object textures, GLboolean[] residences)
+        #region AreTexturesResident(GLsizei n, object textures, Enums.Boolean[] residences)
 
         public static
-        GLboolean AreTexturesResident(GLsizei n, object textures, GLboolean[] residences)
+        GLboolean AreTexturesResident(GLsizei n, object textures, Enums.Boolean[] residences)
         {
             GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
             GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
@@ -16390,10 +9499,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region AreTexturesResident(GLsizei n, GLuint[] textures, GLboolean[] residences)
+        #region AreTexturesResident(GLsizei n, GLuint[] textures, Enums.Boolean[] residences)
 
         public static
-        GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, GLboolean[] residences)
+        GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, Enums.Boolean[] residences)
         {
             GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
             GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
@@ -17486,20 +10595,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region GetHistogram(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
+        #region GetHistogram(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
 
         public static
-        void GetHistogram(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
+        void GetHistogram(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
         {
             GetHistogram_(target, reset, format, type, values);
         }
 
         #endregion
 
-        #region GetHistogram(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+        #region GetHistogram(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
 
         public static
-        void GetHistogram(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+        void GetHistogram(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
         {
             GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
             try
@@ -17606,20 +10715,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region GetMinmax(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
+        #region GetMinmax(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
 
         public static
-        void GetMinmax(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
+        void GetMinmax(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
         {
             GetMinmax_(target, reset, format, type, values);
         }
 
         #endregion
 
-        #region GetMinmax(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+        #region GetMinmax(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
 
         public static
-        void GetMinmax(GLenum target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+        void GetMinmax(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
         {
             GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
             try
@@ -22892,20 +16001,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix2fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix2fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix2fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix2fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix2fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -22920,10 +16029,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix2fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix2fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -22938,20 +16047,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix3fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix3fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix3fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix3fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix3fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -22966,10 +16075,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix3fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix3fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -22984,20 +16093,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix4fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix4fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix4fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix4fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix4fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -23012,10 +16121,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix4fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix4fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24088,20 +17197,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, IntPtr pointer)
+        #region VertexAttribPointer(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer)
 
         public static
-        void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, IntPtr pointer)
+        void VertexAttribPointer(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer)
         {
             VertexAttribPointer_(index, size, type, normalized, stride, pointer);
         }
 
         #endregion
 
-        #region VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, object pointer)
+        #region VertexAttribPointer(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, object pointer)
 
         public static
-        void VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, object pointer)
+        void VertexAttribPointer(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, object pointer)
         {
             GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
             try
@@ -24116,20 +17225,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix2x3fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix2x3fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix2x3fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix2x3fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix2x3fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24144,10 +17253,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix2x3fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix2x3fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24162,20 +17271,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix3x2fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix3x2fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix3x2fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix3x2fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix3x2fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24190,10 +17299,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix3x2fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix3x2fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24208,20 +17317,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix2x4fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix2x4fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix2x4fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix2x4fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix2x4fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24236,10 +17345,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix2x4fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix2x4fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24254,20 +17363,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix4x2fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix4x2fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix4x2fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix4x2fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix4x2fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24282,10 +17391,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix4x2fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix4x2fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24300,20 +17409,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix3x4fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix3x4fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix3x4fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix3x4fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix3x4fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24328,10 +17437,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix3x4fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix3x4fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24346,20 +17455,20 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        #region UniformMatrix4x3fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
 
         public static
-        void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
+        void UniformMatrix4x3fv(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
         {
             UniformMatrix4x3fv_(location, count, transpose, value);
         }
 
         #endregion
 
-        #region UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        #region UniformMatrix4x3fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
 
         public static
-        void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, object value)
+        void UniformMatrix4x3fv(GLint location, GLsizei count, Enums.Boolean transpose, object value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24374,10 +17483,10 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        #region UniformMatrix4x3fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
 
         public static
-        void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
+        void UniformMatrix4x3fv(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
         {
             GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
             try
@@ -24392,41013 +17501,394 @@ namespace OpenTK.OpenGL
 
         #endregion
 
-        #region MultiTexCoord1dvARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord1dvARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord1dvARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord1dvARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord1dvARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1dvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1dvARB(GLenum target, GLdouble[] v)
-
-        public static
-        void MultiTexCoord1dvARB(GLenum target, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1dvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1fvARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord1fvARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord1fvARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord1fvARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord1fvARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1fvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1fvARB(GLenum target, GLfloat[] v)
-
-        public static
-        void MultiTexCoord1fvARB(GLenum target, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1fvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1ivARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord1ivARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord1ivARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord1ivARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord1ivARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1ivARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1ivARB(GLenum target, GLint[] v)
-
-        public static
-        void MultiTexCoord1ivARB(GLenum target, GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1ivARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1svARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord1svARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord1svARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord1svARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord1svARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1svARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1svARB(GLenum target, GLshort[] v)
-
-        public static
-        void MultiTexCoord1svARB(GLenum target, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1svARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2dvARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord2dvARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord2dvARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord2dvARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord2dvARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2dvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2dvARB(GLenum target, GLdouble[] v)
-
-        public static
-        void MultiTexCoord2dvARB(GLenum target, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2dvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2fvARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord2fvARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord2fvARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord2fvARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord2fvARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2fvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2fvARB(GLenum target, GLfloat[] v)
-
-        public static
-        void MultiTexCoord2fvARB(GLenum target, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2fvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2ivARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord2ivARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord2ivARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord2ivARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord2ivARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2ivARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2ivARB(GLenum target, GLint[] v)
-
-        public static
-        void MultiTexCoord2ivARB(GLenum target, GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2ivARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2svARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord2svARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord2svARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord2svARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord2svARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2svARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2svARB(GLenum target, GLshort[] v)
-
-        public static
-        void MultiTexCoord2svARB(GLenum target, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2svARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3dvARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord3dvARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord3dvARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord3dvARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord3dvARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3dvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3dvARB(GLenum target, GLdouble[] v)
-
-        public static
-        void MultiTexCoord3dvARB(GLenum target, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3dvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3fvARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord3fvARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord3fvARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord3fvARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord3fvARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3fvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3fvARB(GLenum target, GLfloat[] v)
-
-        public static
-        void MultiTexCoord3fvARB(GLenum target, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3fvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3ivARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord3ivARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord3ivARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord3ivARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord3ivARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3ivARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3ivARB(GLenum target, GLint[] v)
-
-        public static
-        void MultiTexCoord3ivARB(GLenum target, GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3ivARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3svARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord3svARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord3svARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord3svARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord3svARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3svARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3svARB(GLenum target, GLshort[] v)
-
-        public static
-        void MultiTexCoord3svARB(GLenum target, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3svARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4dvARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord4dvARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord4dvARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord4dvARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord4dvARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4dvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4dvARB(GLenum target, GLdouble[] v)
-
-        public static
-        void MultiTexCoord4dvARB(GLenum target, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4dvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4fvARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord4fvARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord4fvARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord4fvARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord4fvARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4fvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4fvARB(GLenum target, GLfloat[] v)
-
-        public static
-        void MultiTexCoord4fvARB(GLenum target, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4fvARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4ivARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord4ivARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord4ivARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord4ivARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord4ivARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4ivARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4ivARB(GLenum target, GLint[] v)
-
-        public static
-        void MultiTexCoord4ivARB(GLenum target, GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4ivARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4svARB(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord4svARB(GLenum target, IntPtr v)
-        {
-            MultiTexCoord4svARB_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord4svARB(GLenum target, object v)
-
-        public static
-        void MultiTexCoord4svARB(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4svARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4svARB(GLenum target, GLshort[] v)
-
-        public static
-        void MultiTexCoord4svARB(GLenum target, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4svARB_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region LoadTransposeMatrixfARB(IntPtr m)
-
-        public static
-        void LoadTransposeMatrixfARB(IntPtr m)
-        {
-            LoadTransposeMatrixfARB_(m);
-        }
-
-        #endregion
-
-        #region LoadTransposeMatrixfARB(object m)
-
-        public static
-        void LoadTransposeMatrixfARB(object m)
-        {
-            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
-            try
-            {
-                LoadTransposeMatrixfARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region LoadTransposeMatrixfARB(GLfloat[] m)
-
-        public static
-        void LoadTransposeMatrixfARB(GLfloat[] m)
-        {
-            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
-            try
-            {
-                LoadTransposeMatrixfARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region LoadTransposeMatrixdARB(IntPtr m)
-
-        public static
-        void LoadTransposeMatrixdARB(IntPtr m)
-        {
-            LoadTransposeMatrixdARB_(m);
-        }
-
-        #endregion
-
-        #region LoadTransposeMatrixdARB(object m)
-
-        public static
-        void LoadTransposeMatrixdARB(object m)
-        {
-            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
-            try
-            {
-                LoadTransposeMatrixdARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region LoadTransposeMatrixdARB(GLdouble[] m)
-
-        public static
-        void LoadTransposeMatrixdARB(GLdouble[] m)
-        {
-            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
-            try
-            {
-                LoadTransposeMatrixdARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultTransposeMatrixfARB(IntPtr m)
-
-        public static
-        void MultTransposeMatrixfARB(IntPtr m)
-        {
-            MultTransposeMatrixfARB_(m);
-        }
-
-        #endregion
-
-        #region MultTransposeMatrixfARB(object m)
-
-        public static
-        void MultTransposeMatrixfARB(object m)
-        {
-            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
-            try
-            {
-                MultTransposeMatrixfARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultTransposeMatrixfARB(GLfloat[] m)
-
-        public static
-        void MultTransposeMatrixfARB(GLfloat[] m)
-        {
-            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
-            try
-            {
-                MultTransposeMatrixfARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultTransposeMatrixdARB(IntPtr m)
-
-        public static
-        void MultTransposeMatrixdARB(IntPtr m)
-        {
-            MultTransposeMatrixdARB_(m);
-        }
-
-        #endregion
-
-        #region MultTransposeMatrixdARB(object m)
-
-        public static
-        void MultTransposeMatrixdARB(object m)
-        {
-            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
-            try
-            {
-                MultTransposeMatrixdARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultTransposeMatrixdARB(GLdouble[] m)
-
-        public static
-        void MultTransposeMatrixdARB(GLdouble[] m)
-        {
-            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
-            try
-            {
-                MultTransposeMatrixdARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data)
-
-        public static
-        void CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data)
-        {
-            CompressedTexImage3DARB_(target, level, internalformat, width, height, depth, border, imageSize, data);
-        }
-
-        #endregion
-
-        #region CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
-
-        public static
-        void CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                CompressedTexImage3DARB_(target, level, internalformat, width, height, depth, border, imageSize, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data)
-
-        public static
-        void CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data)
-        {
-            CompressedTexImage2DARB_(target, level, internalformat, width, height, border, imageSize, data);
-        }
-
-        #endregion
-
-        #region CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
-
-        public static
-        void CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                CompressedTexImage2DARB_(target, level, internalformat, width, height, border, imageSize, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data)
-
-        public static
-        void CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data)
-        {
-            CompressedTexImage1DARB_(target, level, internalformat, width, border, imageSize, data);
-        }
-
-        #endregion
-
-        #region CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
-
-        public static
-        void CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                CompressedTexImage1DARB_(target, level, internalformat, width, border, imageSize, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
-
-        public static
-        void CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
-        {
-            CompressedTexSubImage3DARB_(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-        }
-
-        #endregion
-
-        #region CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, object data)
-
-        public static
-        void CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                CompressedTexSubImage3DARB_(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
-
-        public static
-        void CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
-        {
-            CompressedTexSubImage2DARB_(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-        }
-
-        #endregion
-
-        #region CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, object data)
-
-        public static
-        void CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                CompressedTexSubImage2DARB_(target, level, xoffset, yoffset, width, height, format, imageSize, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
-
-        public static
-        void CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
-        {
-            CompressedTexSubImage1DARB_(target, level, xoffset, width, format, imageSize, data);
-        }
-
-        #endregion
-
-        #region CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, object data)
-
-        public static
-        void CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                CompressedTexSubImage1DARB_(target, level, xoffset, width, format, imageSize, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, IntPtr img)
-
-        public static
-        void GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, IntPtr img)
-        {
-            GetCompressedTexImageARB_(target, level, img);
-        }
-
-        #endregion
-
-        #region GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, object img)
-
-        public static
-        void GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, object img)
-        {
-            GCHandle h0 = GCHandle.Alloc(img, GCHandleType.Pinned);
-            try
-            {
-                GetCompressedTexImageARB_(target, level, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PointParameterfvARB(GLenum pname, IntPtr parameters)
-
-        public static
-        void PointParameterfvARB(GLenum pname, IntPtr parameters)
-        {
-            PointParameterfvARB_(pname, parameters);
-        }
-
-        #endregion
-
-        #region PointParameterfvARB(GLenum pname, object parameters)
-
-        public static
-        void PointParameterfvARB(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PointParameterfvARB_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PointParameterfvARB(GLenum pname, GLfloat[] parameters)
-
-        public static
-        void PointParameterfvARB(GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PointParameterfvARB_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightbvARB(GLint size, IntPtr weights)
-
-        public static
-        void WeightbvARB(GLint size, IntPtr weights)
-        {
-            WeightbvARB_(size, weights);
-        }
-
-        #endregion
-
-        #region WeightbvARB(GLint size, object weights)
-
-        public static
-        void WeightbvARB(GLint size, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightbvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightbvARB(GLint size, GLbyte[] weights)
-
-        public static
-        void WeightbvARB(GLint size, GLbyte[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightbvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightsvARB(GLint size, IntPtr weights)
-
-        public static
-        void WeightsvARB(GLint size, IntPtr weights)
-        {
-            WeightsvARB_(size, weights);
-        }
-
-        #endregion
-
-        #region WeightsvARB(GLint size, object weights)
-
-        public static
-        void WeightsvARB(GLint size, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightsvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightsvARB(GLint size, GLshort[] weights)
-
-        public static
-        void WeightsvARB(GLint size, GLshort[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightsvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightivARB(GLint size, IntPtr weights)
-
-        public static
-        void WeightivARB(GLint size, IntPtr weights)
-        {
-            WeightivARB_(size, weights);
-        }
-
-        #endregion
-
-        #region WeightivARB(GLint size, object weights)
-
-        public static
-        void WeightivARB(GLint size, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightivARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightivARB(GLint size, GLint[] weights)
-
-        public static
-        void WeightivARB(GLint size, GLint[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightivARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightfvARB(GLint size, IntPtr weights)
-
-        public static
-        void WeightfvARB(GLint size, IntPtr weights)
-        {
-            WeightfvARB_(size, weights);
-        }
-
-        #endregion
-
-        #region WeightfvARB(GLint size, object weights)
-
-        public static
-        void WeightfvARB(GLint size, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightfvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightfvARB(GLint size, GLfloat[] weights)
-
-        public static
-        void WeightfvARB(GLint size, GLfloat[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightfvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightdvARB(GLint size, IntPtr weights)
-
-        public static
-        void WeightdvARB(GLint size, IntPtr weights)
-        {
-            WeightdvARB_(size, weights);
-        }
-
-        #endregion
-
-        #region WeightdvARB(GLint size, object weights)
-
-        public static
-        void WeightdvARB(GLint size, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightdvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightdvARB(GLint size, GLdouble[] weights)
-
-        public static
-        void WeightdvARB(GLint size, GLdouble[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightdvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightubvARB(GLint size, IntPtr weights)
-
-        public static
-        void WeightubvARB(GLint size, IntPtr weights)
-        {
-            WeightubvARB_(size, weights);
-        }
-
-        #endregion
-
-        #region WeightubvARB(GLint size, object weights)
-
-        public static
-        void WeightubvARB(GLint size, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightubvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightubvARB(GLint size, GLubyte[] weights)
-
-        public static
-        void WeightubvARB(GLint size, GLubyte[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightubvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightusvARB(GLint size, IntPtr weights)
-
-        public static
-        void WeightusvARB(GLint size, IntPtr weights)
-        {
-            WeightusvARB_(size, weights);
-        }
-
-        #endregion
-
-        #region WeightusvARB(GLint size, object weights)
-
-        public static
-        void WeightusvARB(GLint size, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightusvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightusvARB(GLint size, GLushort[] weights)
-
-        public static
-        void WeightusvARB(GLint size, GLushort[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightusvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightuivARB(GLint size, IntPtr weights)
-
-        public static
-        void WeightuivARB(GLint size, IntPtr weights)
-        {
-            WeightuivARB_(size, weights);
-        }
-
-        #endregion
-
-        #region WeightuivARB(GLint size, object weights)
-
-        public static
-        void WeightuivARB(GLint size, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightuivARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightuivARB(GLint size, GLuint[] weights)
-
-        public static
-        void WeightuivARB(GLint size, GLuint[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                WeightuivARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WeightPointerARB(GLint size, GLenum type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void WeightPointerARB(GLint size, GLenum type, GLsizei stride, IntPtr pointer)
-        {
-            WeightPointerARB_(size, type, stride, pointer);
-        }
-
-        #endregion
-
-        #region WeightPointerARB(GLint size, GLenum type, GLsizei stride, object pointer)
-
-        public static
-        void WeightPointerARB(GLint size, GLenum type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                WeightPointerARB_(size, type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MatrixIndexubvARB(GLint size, IntPtr indices)
-
-        public static
-        void MatrixIndexubvARB(GLint size, IntPtr indices)
-        {
-            MatrixIndexubvARB_(size, indices);
-        }
-
-        #endregion
-
-        #region MatrixIndexubvARB(GLint size, object indices)
-
-        public static
-        void MatrixIndexubvARB(GLint size, object indices)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MatrixIndexubvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MatrixIndexubvARB(GLint size, GLubyte[] indices)
-
-        public static
-        void MatrixIndexubvARB(GLint size, GLubyte[] indices)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MatrixIndexubvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MatrixIndexusvARB(GLint size, IntPtr indices)
-
-        public static
-        void MatrixIndexusvARB(GLint size, IntPtr indices)
-        {
-            MatrixIndexusvARB_(size, indices);
-        }
-
-        #endregion
-
-        #region MatrixIndexusvARB(GLint size, object indices)
-
-        public static
-        void MatrixIndexusvARB(GLint size, object indices)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MatrixIndexusvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MatrixIndexusvARB(GLint size, GLushort[] indices)
-
-        public static
-        void MatrixIndexusvARB(GLint size, GLushort[] indices)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MatrixIndexusvARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MatrixIndexuivARB(GLint size, IntPtr indices)
-
-        public static
-        void MatrixIndexuivARB(GLint size, IntPtr indices)
-        {
-            MatrixIndexuivARB_(size, indices);
-        }
-
-        #endregion
-
-        #region MatrixIndexuivARB(GLint size, object indices)
-
-        public static
-        void MatrixIndexuivARB(GLint size, object indices)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MatrixIndexuivARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MatrixIndexuivARB(GLint size, GLuint[] indices)
-
-        public static
-        void MatrixIndexuivARB(GLint size, GLuint[] indices)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MatrixIndexuivARB_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void MatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, IntPtr pointer)
-        {
-            MatrixIndexPointerARB_(size, type, stride, pointer);
-        }
-
-        #endregion
-
-        #region MatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, object pointer)
-
-        public static
-        void MatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                MatrixIndexPointerARB_(size, type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2dvARB(IntPtr v)
-
-        public static
-        void WindowPos2dvARB(IntPtr v)
-        {
-            WindowPos2dvARB_(v);
-        }
-
-        #endregion
-
-        #region WindowPos2dvARB(object v)
-
-        public static
-        void WindowPos2dvARB(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2dvARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2dvARB(GLdouble[] v)
-
-        public static
-        void WindowPos2dvARB(GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2dvARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2fvARB(IntPtr v)
-
-        public static
-        void WindowPos2fvARB(IntPtr v)
-        {
-            WindowPos2fvARB_(v);
-        }
-
-        #endregion
-
-        #region WindowPos2fvARB(object v)
-
-        public static
-        void WindowPos2fvARB(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2fvARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2fvARB(GLfloat[] v)
-
-        public static
-        void WindowPos2fvARB(GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2fvARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2ivARB(IntPtr v)
-
-        public static
-        void WindowPos2ivARB(IntPtr v)
-        {
-            WindowPos2ivARB_(v);
-        }
-
-        #endregion
-
-        #region WindowPos2ivARB(object v)
-
-        public static
-        void WindowPos2ivARB(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2ivARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2ivARB(GLint[] v)
-
-        public static
-        void WindowPos2ivARB(GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2ivARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2svARB(IntPtr v)
-
-        public static
-        void WindowPos2svARB(IntPtr v)
-        {
-            WindowPos2svARB_(v);
-        }
-
-        #endregion
-
-        #region WindowPos2svARB(object v)
-
-        public static
-        void WindowPos2svARB(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2svARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2svARB(GLshort[] v)
-
-        public static
-        void WindowPos2svARB(GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2svARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3dvARB(IntPtr v)
-
-        public static
-        void WindowPos3dvARB(IntPtr v)
-        {
-            WindowPos3dvARB_(v);
-        }
-
-        #endregion
-
-        #region WindowPos3dvARB(object v)
-
-        public static
-        void WindowPos3dvARB(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3dvARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3dvARB(GLdouble[] v)
-
-        public static
-        void WindowPos3dvARB(GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3dvARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3fvARB(IntPtr v)
-
-        public static
-        void WindowPos3fvARB(IntPtr v)
-        {
-            WindowPos3fvARB_(v);
-        }
-
-        #endregion
-
-        #region WindowPos3fvARB(object v)
-
-        public static
-        void WindowPos3fvARB(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3fvARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3fvARB(GLfloat[] v)
-
-        public static
-        void WindowPos3fvARB(GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3fvARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3ivARB(IntPtr v)
-
-        public static
-        void WindowPos3ivARB(IntPtr v)
-        {
-            WindowPos3ivARB_(v);
-        }
-
-        #endregion
-
-        #region WindowPos3ivARB(object v)
-
-        public static
-        void WindowPos3ivARB(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3ivARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3ivARB(GLint[] v)
-
-        public static
-        void WindowPos3ivARB(GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3ivARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3svARB(IntPtr v)
-
-        public static
-        void WindowPos3svARB(IntPtr v)
-        {
-            WindowPos3svARB_(v);
-        }
-
-        #endregion
-
-        #region WindowPos3svARB(object v)
-
-        public static
-        void WindowPos3svARB(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3svARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3svARB(GLshort[] v)
-
-        public static
-        void WindowPos3svARB(GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3svARB_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1dvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib1dvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib1dvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib1dvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib1dvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1dvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1dvARB(GLuint index, GLdouble[] v)
-
-        public static
-        void VertexAttrib1dvARB(GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1dvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1fvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib1fvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib1fvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib1fvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib1fvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1fvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1fvARB(GLuint index, GLfloat[] v)
-
-        public static
-        void VertexAttrib1fvARB(GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1fvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1svARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib1svARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib1svARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib1svARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib1svARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1svARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1svARB(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib1svARB(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1svARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2dvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib2dvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib2dvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib2dvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib2dvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2dvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2dvARB(GLuint index, GLdouble[] v)
-
-        public static
-        void VertexAttrib2dvARB(GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2dvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2fvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib2fvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib2fvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib2fvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib2fvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2fvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2fvARB(GLuint index, GLfloat[] v)
-
-        public static
-        void VertexAttrib2fvARB(GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2fvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2svARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib2svARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib2svARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib2svARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib2svARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2svARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2svARB(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib2svARB(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2svARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3dvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib3dvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib3dvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib3dvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib3dvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3dvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3dvARB(GLuint index, GLdouble[] v)
-
-        public static
-        void VertexAttrib3dvARB(GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3dvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3fvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib3fvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib3fvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib3fvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib3fvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3fvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3fvARB(GLuint index, GLfloat[] v)
-
-        public static
-        void VertexAttrib3fvARB(GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3fvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3svARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib3svARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib3svARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib3svARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib3svARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3svARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3svARB(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib3svARB(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3svARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NbvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4NbvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4NbvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4NbvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4NbvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NbvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NbvARB(GLuint index, GLbyte[] v)
-
-        public static
-        void VertexAttrib4NbvARB(GLuint index, GLbyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NbvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NivARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4NivARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4NivARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4NivARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4NivARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NivARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NivARB(GLuint index, GLint[] v)
-
-        public static
-        void VertexAttrib4NivARB(GLuint index, GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NivARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NsvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4NsvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4NsvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4NsvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4NsvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NsvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NsvARB(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib4NsvARB(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NsvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NubvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4NubvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4NubvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4NubvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4NubvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NubvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NubvARB(GLuint index, GLubyte[] v)
-
-        public static
-        void VertexAttrib4NubvARB(GLuint index, GLubyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NubvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NuivARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4NuivARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4NuivARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4NuivARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4NuivARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NuivARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NuivARB(GLuint index, GLuint[] v)
-
-        public static
-        void VertexAttrib4NuivARB(GLuint index, GLuint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NuivARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NusvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4NusvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4NusvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4NusvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4NusvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NusvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4NusvARB(GLuint index, GLushort[] v)
-
-        public static
-        void VertexAttrib4NusvARB(GLuint index, GLushort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4NusvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4bvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4bvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4bvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4bvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4bvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4bvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4bvARB(GLuint index, GLbyte[] v)
-
-        public static
-        void VertexAttrib4bvARB(GLuint index, GLbyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4bvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4dvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4dvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4dvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4dvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4dvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4dvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4dvARB(GLuint index, GLdouble[] v)
-
-        public static
-        void VertexAttrib4dvARB(GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4dvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4fvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4fvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4fvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4fvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4fvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4fvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4fvARB(GLuint index, GLfloat[] v)
-
-        public static
-        void VertexAttrib4fvARB(GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4fvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4ivARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4ivARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4ivARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4ivARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4ivARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4ivARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4ivARB(GLuint index, GLint[] v)
-
-        public static
-        void VertexAttrib4ivARB(GLuint index, GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4ivARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4svARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4svARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4svARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4svARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4svARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4svARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4svARB(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib4svARB(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4svARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4ubvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4ubvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4ubvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4ubvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4ubvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4ubvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4ubvARB(GLuint index, GLubyte[] v)
-
-        public static
-        void VertexAttrib4ubvARB(GLuint index, GLubyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4ubvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4uivARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4uivARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4uivARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4uivARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4uivARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4uivARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4uivARB(GLuint index, GLuint[] v)
-
-        public static
-        void VertexAttrib4uivARB(GLuint index, GLuint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4uivARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4usvARB(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4usvARB(GLuint index, IntPtr v)
-        {
-            VertexAttrib4usvARB_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4usvARB(GLuint index, object v)
-
-        public static
-        void VertexAttrib4usvARB(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4usvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4usvARB(GLuint index, GLushort[] v)
-
-        public static
-        void VertexAttrib4usvARB(GLuint index, GLushort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4usvARB_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, IntPtr pointer)
-
-        public static
-        void VertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, IntPtr pointer)
-        {
-            VertexAttribPointerARB_(index, size, type, normalized, stride, pointer);
-        }
-
-        #endregion
-
-        #region VertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, object pointer)
-
-        public static
-        void VertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribPointerARB_(index, size, type, normalized, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramStringARB(GLenum target, GLenum format, GLsizei len, IntPtr @string)
-
-        public static
-        void ProgramStringARB(GLenum target, GLenum format, GLsizei len, IntPtr @string)
-        {
-            ProgramStringARB_(target, format, len, @string);
-        }
-
-        #endregion
-
-        #region ProgramStringARB(GLenum target, GLenum format, GLsizei len, object @string)
-
-        public static
-        void ProgramStringARB(GLenum target, GLenum format, GLsizei len, object @string)
-        {
-            GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
-            try
-            {
-                ProgramStringARB_(target, format, len, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteProgramsARB(GLsizei n, IntPtr programs)
-
-        public static
-        void DeleteProgramsARB(GLsizei n, IntPtr programs)
-        {
-            DeleteProgramsARB_(n, programs);
-        }
-
-        #endregion
-
-        #region DeleteProgramsARB(GLsizei n, object programs)
-
-        public static
-        void DeleteProgramsARB(GLsizei n, object programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                DeleteProgramsARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteProgramsARB(GLsizei n, GLuint[] programs)
-
-        public static
-        void DeleteProgramsARB(GLsizei n, GLuint[] programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                DeleteProgramsARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenProgramsARB(GLsizei n, IntPtr programs)
-
-        public static
-        void GenProgramsARB(GLsizei n, IntPtr programs)
-        {
-            GenProgramsARB_(n, programs);
-        }
-
-        #endregion
-
-        #region GenProgramsARB(GLsizei n, object programs)
-
-        public static
-        void GenProgramsARB(GLsizei n, object programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                GenProgramsARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenProgramsARB(GLsizei n, GLuint[] programs)
-
-        public static
-        void GenProgramsARB(GLsizei n, GLuint[] programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                GenProgramsARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramEnvParameter4dvARB(GLenum target, GLuint index, IntPtr parameters)
-
-        public static
-        void ProgramEnvParameter4dvARB(GLenum target, GLuint index, IntPtr parameters)
-        {
-            ProgramEnvParameter4dvARB_(target, index, parameters);
-        }
-
-        #endregion
-
-        #region ProgramEnvParameter4dvARB(GLenum target, GLuint index, object parameters)
-
-        public static
-        void ProgramEnvParameter4dvARB(GLenum target, GLuint index, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramEnvParameter4dvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramEnvParameter4dvARB(GLenum target, GLuint index, GLdouble[] parameters)
-
-        public static
-        void ProgramEnvParameter4dvARB(GLenum target, GLuint index, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramEnvParameter4dvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramEnvParameter4fvARB(GLenum target, GLuint index, IntPtr parameters)
-
-        public static
-        void ProgramEnvParameter4fvARB(GLenum target, GLuint index, IntPtr parameters)
-        {
-            ProgramEnvParameter4fvARB_(target, index, parameters);
-        }
-
-        #endregion
-
-        #region ProgramEnvParameter4fvARB(GLenum target, GLuint index, object parameters)
-
-        public static
-        void ProgramEnvParameter4fvARB(GLenum target, GLuint index, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramEnvParameter4fvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramEnvParameter4fvARB(GLenum target, GLuint index, GLfloat[] parameters)
-
-        public static
-        void ProgramEnvParameter4fvARB(GLenum target, GLuint index, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramEnvParameter4fvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramLocalParameter4dvARB(GLenum target, GLuint index, IntPtr parameters)
-
-        public static
-        void ProgramLocalParameter4dvARB(GLenum target, GLuint index, IntPtr parameters)
-        {
-            ProgramLocalParameter4dvARB_(target, index, parameters);
-        }
-
-        #endregion
-
-        #region ProgramLocalParameter4dvARB(GLenum target, GLuint index, object parameters)
-
-        public static
-        void ProgramLocalParameter4dvARB(GLenum target, GLuint index, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramLocalParameter4dvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramLocalParameter4dvARB(GLenum target, GLuint index, GLdouble[] parameters)
-
-        public static
-        void ProgramLocalParameter4dvARB(GLenum target, GLuint index, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramLocalParameter4dvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramLocalParameter4fvARB(GLenum target, GLuint index, IntPtr parameters)
-
-        public static
-        void ProgramLocalParameter4fvARB(GLenum target, GLuint index, IntPtr parameters)
-        {
-            ProgramLocalParameter4fvARB_(target, index, parameters);
-        }
-
-        #endregion
-
-        #region ProgramLocalParameter4fvARB(GLenum target, GLuint index, object parameters)
-
-        public static
-        void ProgramLocalParameter4fvARB(GLenum target, GLuint index, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramLocalParameter4fvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramLocalParameter4fvARB(GLenum target, GLuint index, GLfloat[] parameters)
-
-        public static
-        void ProgramLocalParameter4fvARB(GLenum target, GLuint index, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramLocalParameter4fvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramEnvParameterdvARB(GLenum target, GLuint index, IntPtr parameters)
-
-        public static
-        void GetProgramEnvParameterdvARB(GLenum target, GLuint index, IntPtr parameters)
-        {
-            GetProgramEnvParameterdvARB_(target, index, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramEnvParameterdvARB(GLenum target, GLuint index, object parameters)
-
-        public static
-        void GetProgramEnvParameterdvARB(GLenum target, GLuint index, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramEnvParameterdvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble[] parameters)
-
-        public static
-        void GetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramEnvParameterdvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramEnvParameterfvARB(GLenum target, GLuint index, IntPtr parameters)
-
-        public static
-        void GetProgramEnvParameterfvARB(GLenum target, GLuint index, IntPtr parameters)
-        {
-            GetProgramEnvParameterfvARB_(target, index, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramEnvParameterfvARB(GLenum target, GLuint index, object parameters)
-
-        public static
-        void GetProgramEnvParameterfvARB(GLenum target, GLuint index, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramEnvParameterfvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat[] parameters)
-
-        public static
-        void GetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramEnvParameterfvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramLocalParameterdvARB(GLenum target, GLuint index, IntPtr parameters)
-
-        public static
-        void GetProgramLocalParameterdvARB(GLenum target, GLuint index, IntPtr parameters)
-        {
-            GetProgramLocalParameterdvARB_(target, index, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramLocalParameterdvARB(GLenum target, GLuint index, object parameters)
-
-        public static
-        void GetProgramLocalParameterdvARB(GLenum target, GLuint index, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramLocalParameterdvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble[] parameters)
-
-        public static
-        void GetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramLocalParameterdvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramLocalParameterfvARB(GLenum target, GLuint index, IntPtr parameters)
-
-        public static
-        void GetProgramLocalParameterfvARB(GLenum target, GLuint index, IntPtr parameters)
-        {
-            GetProgramLocalParameterfvARB_(target, index, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramLocalParameterfvARB(GLenum target, GLuint index, object parameters)
-
-        public static
-        void GetProgramLocalParameterfvARB(GLenum target, GLuint index, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramLocalParameterfvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat[] parameters)
-
-        public static
-        void GetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramLocalParameterfvARB_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramivARB(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetProgramivARB(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetProgramivARB_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramivARB(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetProgramivARB(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramivARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramivARB(GLenum target, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetProgramivARB(GLenum target, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramivARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramStringARB(GLenum target, GLenum pname, IntPtr @string)
-
-        public static
-        void GetProgramStringARB(GLenum target, GLenum pname, IntPtr @string)
-        {
-            GetProgramStringARB_(target, pname, @string);
-        }
-
-        #endregion
-
-        #region GetProgramStringARB(GLenum target, GLenum pname, object @string)
-
-        public static
-        void GetProgramStringARB(GLenum target, GLenum pname, object @string)
-        {
-            GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
-            try
-            {
-                GetProgramStringARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribdvARB(GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVertexAttribdvARB(GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetVertexAttribdvARB_(index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVertexAttribdvARB(GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetVertexAttribdvARB(GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribdvARB_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble[] parameters)
-
-        public static
-        void GetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribdvARB_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribfvARB(GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVertexAttribfvARB(GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetVertexAttribfvARB_(index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVertexAttribfvARB(GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetVertexAttribfvARB(GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribfvARB_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribfvARB_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribivARB(GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVertexAttribivARB(GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetVertexAttribivARB_(index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVertexAttribivARB(GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetVertexAttribivARB(GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribivARB_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribivARB(GLuint index, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetVertexAttribivARB(GLuint index, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribivARB_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribPointervARB(GLuint index, GLenum pname, IntPtr pointer)
-
-        public static
-        void GetVertexAttribPointervARB(GLuint index, GLenum pname, IntPtr pointer)
-        {
-            GetVertexAttribPointervARB_(index, pname, pointer);
-        }
-
-        #endregion
-
-        #region GetVertexAttribPointervARB(GLuint index, GLenum pname, object pointer)
-
-        public static
-        void GetVertexAttribPointervARB(GLuint index, GLenum pname, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribPointervARB_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribPointervARB(GLuint index, GLenum pname, IntPtr[] pointer)
-
-        public static
-        void GetVertexAttribPointervARB(GLuint index, GLenum pname, IntPtr[] pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribPointervARB_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteBuffersARB(GLsizei n, IntPtr buffers)
-
-        public static
-        void DeleteBuffersARB(GLsizei n, IntPtr buffers)
-        {
-            DeleteBuffersARB_(n, buffers);
-        }
-
-        #endregion
-
-        #region DeleteBuffersARB(GLsizei n, object buffers)
-
-        public static
-        void DeleteBuffersARB(GLsizei n, object buffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
-            try
-            {
-                DeleteBuffersARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteBuffersARB(GLsizei n, GLuint[] buffers)
-
-        public static
-        void DeleteBuffersARB(GLsizei n, GLuint[] buffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
-            try
-            {
-                DeleteBuffersARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenBuffersARB(GLsizei n, IntPtr buffers)
-
-        public static
-        void GenBuffersARB(GLsizei n, IntPtr buffers)
-        {
-            GenBuffersARB_(n, buffers);
-        }
-
-        #endregion
-
-        #region GenBuffersARB(GLsizei n, object buffers)
-
-        public static
-        void GenBuffersARB(GLsizei n, object buffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
-            try
-            {
-                GenBuffersARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenBuffersARB(GLsizei n, GLuint[] buffers)
-
-        public static
-        void GenBuffersARB(GLsizei n, GLuint[] buffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
-            try
-            {
-                GenBuffersARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region BufferDataARB(GLenum target, GLsizeiptrARB size, IntPtr data, GLenum usage)
-
-        public static
-        void BufferDataARB(GLenum target, GLsizeiptrARB size, IntPtr data, GLenum usage)
-        {
-            BufferDataARB_(target, size, data, usage);
-        }
-
-        #endregion
-
-        #region BufferDataARB(GLenum target, GLsizeiptrARB size, object data, GLenum usage)
-
-        public static
-        void BufferDataARB(GLenum target, GLsizeiptrARB size, object data, GLenum usage)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                BufferDataARB_(target, size, h0.AddrOfPinnedObject(), usage);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data)
-
-        public static
-        void BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data)
-        {
-            BufferSubDataARB_(target, offset, size, data);
-        }
-
-        #endregion
-
-        #region BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, object data)
-
-        public static
-        void BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                BufferSubDataARB_(target, offset, size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data)
-
-        public static
-        void GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data)
-        {
-            GetBufferSubDataARB_(target, offset, size, data);
-        }
-
-        #endregion
-
-        #region GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, object data)
-
-        public static
-        void GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetBufferSubDataARB_(target, offset, size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetBufferParameterivARB(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetBufferParameterivARB(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetBufferParameterivARB_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetBufferParameterivARB(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetBufferParameterivARB(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetBufferParameterivARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetBufferParameterivARB(GLenum target, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetBufferParameterivARB(GLenum target, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetBufferParameterivARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetBufferPointervARB(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetBufferPointervARB(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetBufferPointervARB_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetBufferPointervARB(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetBufferPointervARB(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetBufferPointervARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetBufferPointervARB(GLenum target, GLenum pname, IntPtr[] parameters)
-
-        public static
-        void GetBufferPointervARB(GLenum target, GLenum pname, IntPtr[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetBufferPointervARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenQueriesARB(GLsizei n, IntPtr ids)
-
-        public static
-        void GenQueriesARB(GLsizei n, IntPtr ids)
-        {
-            GenQueriesARB_(n, ids);
-        }
-
-        #endregion
-
-        #region GenQueriesARB(GLsizei n, object ids)
-
-        public static
-        void GenQueriesARB(GLsizei n, object ids)
-        {
-            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
-            try
-            {
-                GenQueriesARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenQueriesARB(GLsizei n, GLuint[] ids)
-
-        public static
-        void GenQueriesARB(GLsizei n, GLuint[] ids)
-        {
-            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
-            try
-            {
-                GenQueriesARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteQueriesARB(GLsizei n, IntPtr ids)
-
-        public static
-        void DeleteQueriesARB(GLsizei n, IntPtr ids)
-        {
-            DeleteQueriesARB_(n, ids);
-        }
-
-        #endregion
-
-        #region DeleteQueriesARB(GLsizei n, object ids)
-
-        public static
-        void DeleteQueriesARB(GLsizei n, object ids)
-        {
-            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
-            try
-            {
-                DeleteQueriesARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteQueriesARB(GLsizei n, GLuint[] ids)
-
-        public static
-        void DeleteQueriesARB(GLsizei n, GLuint[] ids)
-        {
-            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
-            try
-            {
-                DeleteQueriesARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, IntPtr parameters)
-
-        public static
-        void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, IntPtr parameters)
-        {
-            GetQueryivARB_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, object parameters)
-
-        public static
-        void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryivARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, GLint[] parameters)
-
-        public static
-        void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryivARB_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters)
-
-        public static
-        void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters)
-        {
-            GetQueryObjectivARB_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, object parameters)
-
-        public static
-        void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryObjectivARB_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, GLint[] parameters)
-
-        public static
-        void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryObjectivARB_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters)
-
-        public static
-        void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters)
-        {
-            GetQueryObjectuivARB_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, object parameters)
-
-        public static
-        void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryObjectuivARB_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, GLuint[] parameters)
-
-        public static
-        void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, GLuint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryObjectuivARB_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, IntPtr length)
-
-        public static
-        void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, IntPtr length)
-        {
-            ShaderSourceARB_(shaderObj, count, @string, length);
-        }
-
-        #endregion
-
-        #region ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, object length)
-
-        public static
-        void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, object length)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                ShaderSourceARB_(shaderObj, count, @string, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, GLint[] length)
-
-        public static
-        void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, GLint[] length)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                ShaderSourceARB_(shaderObj, count, @string, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform1fvARB(GLint location, GLsizei count, IntPtr value)
-
-        public static
-        void Uniform1fvARB(GLint location, GLsizei count, IntPtr value)
-        {
-            Uniform1fvARB_(location, count, value);
-        }
-
-        #endregion
-
-        #region Uniform1fvARB(GLint location, GLsizei count, object value)
-
-        public static
-        void Uniform1fvARB(GLint location, GLsizei count, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform1fvARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform1fvARB(GLint location, GLsizei count, GLfloat[] value)
-
-        public static
-        void Uniform1fvARB(GLint location, GLsizei count, GLfloat[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform1fvARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform2fvARB(GLint location, GLsizei count, IntPtr value)
-
-        public static
-        void Uniform2fvARB(GLint location, GLsizei count, IntPtr value)
-        {
-            Uniform2fvARB_(location, count, value);
-        }
-
-        #endregion
-
-        #region Uniform2fvARB(GLint location, GLsizei count, object value)
-
-        public static
-        void Uniform2fvARB(GLint location, GLsizei count, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform2fvARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform2fvARB(GLint location, GLsizei count, GLfloat[] value)
-
-        public static
-        void Uniform2fvARB(GLint location, GLsizei count, GLfloat[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform2fvARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform3fvARB(GLint location, GLsizei count, IntPtr value)
-
-        public static
-        void Uniform3fvARB(GLint location, GLsizei count, IntPtr value)
-        {
-            Uniform3fvARB_(location, count, value);
-        }
-
-        #endregion
-
-        #region Uniform3fvARB(GLint location, GLsizei count, object value)
-
-        public static
-        void Uniform3fvARB(GLint location, GLsizei count, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform3fvARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform3fvARB(GLint location, GLsizei count, GLfloat[] value)
-
-        public static
-        void Uniform3fvARB(GLint location, GLsizei count, GLfloat[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform3fvARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform4fvARB(GLint location, GLsizei count, IntPtr value)
-
-        public static
-        void Uniform4fvARB(GLint location, GLsizei count, IntPtr value)
-        {
-            Uniform4fvARB_(location, count, value);
-        }
-
-        #endregion
-
-        #region Uniform4fvARB(GLint location, GLsizei count, object value)
-
-        public static
-        void Uniform4fvARB(GLint location, GLsizei count, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform4fvARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform4fvARB(GLint location, GLsizei count, GLfloat[] value)
-
-        public static
-        void Uniform4fvARB(GLint location, GLsizei count, GLfloat[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform4fvARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform1ivARB(GLint location, GLsizei count, IntPtr value)
-
-        public static
-        void Uniform1ivARB(GLint location, GLsizei count, IntPtr value)
-        {
-            Uniform1ivARB_(location, count, value);
-        }
-
-        #endregion
-
-        #region Uniform1ivARB(GLint location, GLsizei count, object value)
-
-        public static
-        void Uniform1ivARB(GLint location, GLsizei count, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform1ivARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform1ivARB(GLint location, GLsizei count, GLint[] value)
-
-        public static
-        void Uniform1ivARB(GLint location, GLsizei count, GLint[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform1ivARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform2ivARB(GLint location, GLsizei count, IntPtr value)
-
-        public static
-        void Uniform2ivARB(GLint location, GLsizei count, IntPtr value)
-        {
-            Uniform2ivARB_(location, count, value);
-        }
-
-        #endregion
-
-        #region Uniform2ivARB(GLint location, GLsizei count, object value)
-
-        public static
-        void Uniform2ivARB(GLint location, GLsizei count, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform2ivARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform2ivARB(GLint location, GLsizei count, GLint[] value)
-
-        public static
-        void Uniform2ivARB(GLint location, GLsizei count, GLint[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform2ivARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform3ivARB(GLint location, GLsizei count, IntPtr value)
-
-        public static
-        void Uniform3ivARB(GLint location, GLsizei count, IntPtr value)
-        {
-            Uniform3ivARB_(location, count, value);
-        }
-
-        #endregion
-
-        #region Uniform3ivARB(GLint location, GLsizei count, object value)
-
-        public static
-        void Uniform3ivARB(GLint location, GLsizei count, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform3ivARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform3ivARB(GLint location, GLsizei count, GLint[] value)
-
-        public static
-        void Uniform3ivARB(GLint location, GLsizei count, GLint[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform3ivARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform4ivARB(GLint location, GLsizei count, IntPtr value)
-
-        public static
-        void Uniform4ivARB(GLint location, GLsizei count, IntPtr value)
-        {
-            Uniform4ivARB_(location, count, value);
-        }
-
-        #endregion
-
-        #region Uniform4ivARB(GLint location, GLsizei count, object value)
-
-        public static
-        void Uniform4ivARB(GLint location, GLsizei count, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform4ivARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Uniform4ivARB(GLint location, GLsizei count, GLint[] value)
-
-        public static
-        void Uniform4ivARB(GLint location, GLsizei count, GLint[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                Uniform4ivARB_(location, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
-
-        public static
-        void UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
-        {
-            UniformMatrix2fvARB_(location, count, transpose, value);
-        }
-
-        #endregion
-
-        #region UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, object value)
-
-        public static
-        void UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                UniformMatrix2fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
-
-        public static
-        void UniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                UniformMatrix2fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
-
-        public static
-        void UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
-        {
-            UniformMatrix3fvARB_(location, count, transpose, value);
-        }
-
-        #endregion
-
-        #region UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, object value)
-
-        public static
-        void UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                UniformMatrix3fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
-
-        public static
-        void UniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                UniformMatrix3fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
-
-        public static
-        void UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, IntPtr value)
-        {
-            UniformMatrix4fvARB_(location, count, transpose, value);
-        }
-
-        #endregion
-
-        #region UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, object value)
-
-        public static
-        void UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                UniformMatrix4fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
-
-        public static
-        void UniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, GLfloat[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                UniformMatrix4fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters)
-
-        public static
-        void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters)
-        {
-            GetObjectParameterfvARB_(obj, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, object parameters)
-
-        public static
-        void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetObjectParameterfvARB_(obj, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLfloat[] parameters)
-
-        public static
-        void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetObjectParameterfvARB_(obj, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters)
-
-        public static
-        void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters)
-        {
-            GetObjectParameterivARB_(obj, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, object parameters)
-
-        public static
-        void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetObjectParameterivARB_(obj, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLint[] parameters)
-
-        public static
-        void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetObjectParameterivARB_(obj, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder infoLog)
-
-        public static
-        void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder infoLog)
-        {
-            GetInfoLogARB_(obj, maxLength, length, infoLog);
-        }
-
-        #endregion
-
-        #region GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, object length, StringBuilder infoLog)
-
-        public static
-        void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, object length, StringBuilder infoLog)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                GetInfoLogARB_(obj, maxLength, h0.AddrOfPinnedObject(), infoLog);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, StringBuilder infoLog)
-
-        public static
-        void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, StringBuilder infoLog)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                GetInfoLogARB_(obj, maxLength, h0.AddrOfPinnedObject(), infoLog);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, IntPtr obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, IntPtr obj)
-        {
-            GetAttachedObjectsARB_(containerObj, maxCount, count, obj);
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, object obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, object obj)
-        {
-            GCHandle h0 = GCHandle.Alloc(obj, GCHandleType.Pinned);
-            try
-            {
-                GetAttachedObjectsARB_(containerObj, maxCount, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, GLhandleARB[] obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, GLhandleARB[] obj)
-        {
-            GCHandle h0 = GCHandle.Alloc(obj, GCHandleType.Pinned);
-            try
-            {
-                GetAttachedObjectsARB_(containerObj, maxCount, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, IntPtr obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, IntPtr obj)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), obj);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, object obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, object obj)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
-            try
-            {
-                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, GLhandleARB[] obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, GLhandleARB[] obj)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
-            try
-            {
-                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, IntPtr obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, IntPtr obj)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), obj);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, object obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, object obj)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
-            try
-            {
-                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB[] obj)
-
-        public static
-        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB[] obj)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
-            try
-            {
-                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name)
-        {
-            GetActiveUniformARB_(programObj, index, maxLength, length, size, type, name);
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, length, size, h0.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, length, size, h0.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, type, name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, type, name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, object type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
-
-        public static
-        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetUniformfvARB(GLhandleARB programObj, GLint location, IntPtr parameters)
-
-        public static
-        void GetUniformfvARB(GLhandleARB programObj, GLint location, IntPtr parameters)
-        {
-            GetUniformfvARB_(programObj, location, parameters);
-        }
-
-        #endregion
-
-        #region GetUniformfvARB(GLhandleARB programObj, GLint location, object parameters)
-
-        public static
-        void GetUniformfvARB(GLhandleARB programObj, GLint location, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetUniformfvARB_(programObj, location, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat[] parameters)
-
-        public static
-        void GetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetUniformfvARB_(programObj, location, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetUniformivARB(GLhandleARB programObj, GLint location, IntPtr parameters)
-
-        public static
-        void GetUniformivARB(GLhandleARB programObj, GLint location, IntPtr parameters)
-        {
-            GetUniformivARB_(programObj, location, parameters);
-        }
-
-        #endregion
-
-        #region GetUniformivARB(GLhandleARB programObj, GLint location, object parameters)
-
-        public static
-        void GetUniformivARB(GLhandleARB programObj, GLint location, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetUniformivARB_(programObj, location, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetUniformivARB(GLhandleARB programObj, GLint location, GLint[] parameters)
-
-        public static
-        void GetUniformivARB(GLhandleARB programObj, GLint location, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetUniformivARB_(programObj, location, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder source)
-
-        public static
-        void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder source)
-        {
-            GetShaderSourceARB_(obj, maxLength, length, source);
-        }
-
-        #endregion
-
-        #region GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, object length, StringBuilder source)
-
-        public static
-        void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, object length, StringBuilder source)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                GetShaderSourceARB_(obj, maxLength, h0.AddrOfPinnedObject(), source);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, StringBuilder source)
-
-        public static
-        void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, StringBuilder source)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                GetShaderSourceARB_(obj, maxLength, h0.AddrOfPinnedObject(), source);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name)
-        {
-            GetActiveAttribARB_(programObj, index, maxLength, length, size, type, name);
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, length, size, h0.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, length, size, h0.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, type, name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, type, name);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, IntPtr type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, IntPtr type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, object type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, object type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-
-        public static
-        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
-        {
-            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
-            try
-            {
-                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DrawBuffersARB(GLsizei n, IntPtr bufs)
-
-        public static
-        void DrawBuffersARB(GLsizei n, IntPtr bufs)
-        {
-            DrawBuffersARB_(n, bufs);
-        }
-
-        #endregion
-
-        #region DrawBuffersARB(GLsizei n, object bufs)
-
-        public static
-        void DrawBuffersARB(GLsizei n, object bufs)
-        {
-            GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
-            try
-            {
-                DrawBuffersARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DrawBuffersARB(GLsizei n, GLenum[] bufs)
-
-        public static
-        void DrawBuffersARB(GLsizei n, GLenum[] bufs)
-        {
-            GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
-            try
-            {
-                DrawBuffersARB_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-
-        public static
-        void TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-        {
-            TexImage3DEXT_(target, level, internalformat, width, height, depth, border, format, type, pixels);
-        }
-
-        #endregion
-
-        #region TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-
-        public static
-        void TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-        {
-            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
-            try
-            {
-                TexImage3DEXT_(target, level, internalformat, width, height, depth, border, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-
-        public static
-        void TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-        {
-            TexSubImage3DEXT_(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-        }
-
-        #endregion
-
-        #region TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-
-        public static
-        void TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-        {
-            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
-            try
-            {
-                TexSubImage3DEXT_(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, IntPtr weights)
-
-        public static
-        void GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, IntPtr weights)
-        {
-            GetTexFilterFuncSGIS_(target, filter, weights);
-        }
-
-        #endregion
-
-        #region GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, object weights)
-
-        public static
-        void GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                GetTexFilterFuncSGIS_(target, filter, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLfloat[] weights)
-
-        public static
-        void GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLfloat[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                GetTexFilterFuncSGIS_(target, filter, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, IntPtr weights)
-
-        public static
-        void TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, IntPtr weights)
-        {
-            TexFilterFuncSGIS_(target, filter, n, weights);
-        }
-
-        #endregion
-
-        #region TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, object weights)
-
-        public static
-        void TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, object weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                TexFilterFuncSGIS_(target, filter, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, GLfloat[] weights)
-
-        public static
-        void TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, GLfloat[] weights)
-        {
-            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
-            try
-            {
-                TexFilterFuncSGIS_(target, filter, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-
-        public static
-        void TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-        {
-            TexSubImage1DEXT_(target, level, xoffset, width, format, type, pixels);
-        }
-
-        #endregion
-
-        #region TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-
-        public static
-        void TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-        {
-            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
-            try
-            {
-                TexSubImage1DEXT_(target, level, xoffset, width, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-
-        public static
-        void TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-        {
-            TexSubImage2DEXT_(target, level, xoffset, yoffset, width, height, format, type, pixels);
-        }
-
-        #endregion
-
-        #region TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-
-        public static
-        void TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-        {
-            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
-            try
-            {
-                TexSubImage2DEXT_(target, level, xoffset, yoffset, width, height, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetHistogramEXT(Enums.HistogramTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
-
-        public static
-        void GetHistogramEXT(Enums.HistogramTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
-        {
-            GetHistogramEXT_(target, reset, format, type, values);
-        }
-
-        #endregion
-
-        #region GetHistogramEXT(Enums.HistogramTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
-
-        public static
-        void GetHistogramEXT(Enums.HistogramTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
-        {
-            GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
-            try
-            {
-                GetHistogramEXT_(target, reset, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters)
-
-        public static
-        void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters)
-        {
-            GetHistogramParameterfvEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, object parameters)
-
-        public static
-        void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetHistogramParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLfloat[] parameters)
-
-        public static
-        void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetHistogramParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters)
-
-        public static
-        void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters)
-        {
-            GetHistogramParameterivEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, object parameters)
-
-        public static
-        void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetHistogramParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLint[] parameters)
-
-        public static
-        void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetHistogramParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMinmaxEXT(Enums.MinmaxTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
-
-        public static
-        void GetMinmaxEXT(Enums.MinmaxTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
-        {
-            GetMinmaxEXT_(target, reset, format, type, values);
-        }
-
-        #endregion
-
-        #region GetMinmaxEXT(Enums.MinmaxTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
-
-        public static
-        void GetMinmaxEXT(Enums.MinmaxTargetEXT target, GLboolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
-        {
-            GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
-            try
-            {
-                GetMinmaxEXT_(target, reset, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters)
-
-        public static
-        void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters)
-        {
-            GetMinmaxParameterfvEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, object parameters)
-
-        public static
-        void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMinmaxParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLfloat[] parameters)
-
-        public static
-        void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMinmaxParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters)
-
-        public static
-        void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters)
-        {
-            GetMinmaxParameterivEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, object parameters)
-
-        public static
-        void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMinmaxParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLint[] parameters)
-
-        public static
-        void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMinmaxParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
-
-        public static
-        void ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
-        {
-            ConvolutionFilter1DEXT_(target, internalformat, width, format, type, image);
-        }
-
-        #endregion
-
-        #region ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object image)
-
-        public static
-        void ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object image)
-        {
-            GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
-            try
-            {
-                ConvolutionFilter1DEXT_(target, internalformat, width, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
-
-        public static
-        void ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
-        {
-            ConvolutionFilter2DEXT_(target, internalformat, width, height, format, type, image);
-        }
-
-        #endregion
-
-        #region ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object image)
-
-        public static
-        void ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object image)
-        {
-            GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
-            try
-            {
-                ConvolutionFilter2DEXT_(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
-
-        public static
-        void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
-        {
-            ConvolutionParameterfvEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
-
-        public static
-        void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ConvolutionParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] parameters)
-
-        public static
-        void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ConvolutionParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
-
-        public static
-        void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
-        {
-            ConvolutionParameterivEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
-
-        public static
-        void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ConvolutionParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] parameters)
-
-        public static
-        void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ConvolutionParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
-
-        public static
-        void GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
-        {
-            GetConvolutionFilterEXT_(target, format, type, image);
-        }
-
-        #endregion
-
-        #region GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object image)
-
-        public static
-        void GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object image)
-        {
-            GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
-            try
-            {
-                GetConvolutionFilterEXT_(target, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
-
-        public static
-        void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
-        {
-            GetConvolutionParameterfvEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
-
-        public static
-        void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetConvolutionParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] parameters)
-
-        public static
-        void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetConvolutionParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
-
-        public static
-        void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
-        {
-            GetConvolutionParameterivEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
-
-        public static
-        void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetConvolutionParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] parameters)
-
-        public static
-        void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetConvolutionParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, IntPtr span)
-
-        public static
-        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, IntPtr span)
-        {
-            GetSeparableFilterEXT_(target, format, type, row, column, span);
-        }
-
-        #endregion
-
-        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, object span)
-
-        public static
-        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, object span)
-        {
-            GCHandle h0 = GCHandle.Alloc(span, GCHandleType.Pinned);
-            try
-            {
-                GetSeparableFilterEXT_(target, format, type, row, column, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column, IntPtr span)
-
-        public static
-        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column, IntPtr span)
-        {
-            GCHandle h0 = GCHandle.Alloc(column, GCHandleType.Pinned);
-            try
-            {
-                GetSeparableFilterEXT_(target, format, type, row, h0.AddrOfPinnedObject(), span);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column, object span)
-
-        public static
-        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column, object span)
-        {
-            GCHandle h0 = GCHandle.Alloc(column, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(span, GCHandleType.Pinned);
-            try
-            {
-                GetSeparableFilterEXT_(target, format, type, row, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column, IntPtr span)
-
-        public static
-        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column, IntPtr span)
-        {
-            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
-            try
-            {
-                GetSeparableFilterEXT_(target, format, type, h0.AddrOfPinnedObject(), column, span);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column, object span)
-
-        public static
-        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column, object span)
-        {
-            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(span, GCHandleType.Pinned);
-            try
-            {
-                GetSeparableFilterEXT_(target, format, type, h0.AddrOfPinnedObject(), column, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, IntPtr span)
-
-        public static
-        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, IntPtr span)
-        {
-            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
-            try
-            {
-                GetSeparableFilterEXT_(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), span);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, object span)
-
-        public static
-        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, object span)
-        {
-            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
-            try
-            {
-                GetSeparableFilterEXT_(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column)
-
-        public static
-        void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column)
-        {
-            SeparableFilter2DEXT_(target, internalformat, width, height, format, type, row, column);
-        }
-
-        #endregion
-
-        #region SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column)
-
-        public static
-        void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column)
-        {
-            GCHandle h0 = GCHandle.Alloc(column, GCHandleType.Pinned);
-            try
-            {
-                SeparableFilter2DEXT_(target, internalformat, width, height, format, type, row, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column)
-
-        public static
-        void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column)
-        {
-            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
-            try
-            {
-                SeparableFilter2DEXT_(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), column);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, object column)
-
-        public static
-        void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, object column)
-        {
-            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
-            try
-            {
-                SeparableFilter2DEXT_(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
-
-        public static
-        void ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
-        {
-            ColorTableSGI_(target, internalformat, width, format, type, table);
-        }
-
-        #endregion
-
-        #region ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
-
-        public static
-        void ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
-        {
-            GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
-            try
-            {
-                ColorTableSGI_(target, internalformat, width, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters)
-
-        public static
-        void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters)
-        {
-            ColorTableParameterfvSGI_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, object parameters)
-
-        public static
-        void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ColorTableParameterfvSGI_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLfloat[] parameters)
-
-        public static
-        void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ColorTableParameterfvSGI_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters)
-
-        public static
-        void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters)
-        {
-            ColorTableParameterivSGI_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, object parameters)
-
-        public static
-        void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ColorTableParameterivSGI_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLint[] parameters)
-
-        public static
-        void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ColorTableParameterivSGI_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
-
-        public static
-        void GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
-        {
-            GetColorTableSGI_(target, format, type, table);
-        }
-
-        #endregion
-
-        #region GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, object table)
-
-        public static
-        void GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, object table)
-        {
-            GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableSGI_(target, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters)
-
-        public static
-        void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters)
-        {
-            GetColorTableParameterfvSGI_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, object parameters)
-
-        public static
-        void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableParameterfvSGI_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLfloat[] parameters)
-
-        public static
-        void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableParameterfvSGI_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters)
-
-        public static
-        void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters)
-        {
-            GetColorTableParameterivSGI_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, object parameters)
-
-        public static
-        void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableParameterivSGI_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLint[] parameters)
-
-        public static
-        void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableParameterivSGI_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
-
-        public static
-        void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
-        {
-            PixelTexGenParameterivSGIS_(pname, parameters);
-        }
-
-        #endregion
-
-        #region PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
-
-        public static
-        void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PixelTexGenParameterivSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] parameters)
-
-        public static
-        void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PixelTexGenParameterivSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
-
-        public static
-        void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
-        {
-            PixelTexGenParameterfvSGIS_(pname, parameters);
-        }
-
-        #endregion
-
-        #region PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
-
-        public static
-        void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PixelTexGenParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] parameters)
-
-        public static
-        void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PixelTexGenParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
-
-        public static
-        void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
-        {
-            GetPixelTexGenParameterivSGIS_(pname, parameters);
-        }
-
-        #endregion
-
-        #region GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
-
-        public static
-        void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetPixelTexGenParameterivSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] parameters)
-
-        public static
-        void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetPixelTexGenParameterivSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
-
-        public static
-        void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
-        {
-            GetPixelTexGenParameterfvSGIS_(pname, parameters);
-        }
-
-        #endregion
-
-        #region GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
-
-        public static
-        void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetPixelTexGenParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] parameters)
-
-        public static
-        void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetPixelTexGenParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-
-        public static
-        void TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-        {
-            TexImage4DSGIS_(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);
-        }
-
-        #endregion
-
-        #region TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-
-        public static
-        void TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-        {
-            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
-            try
-            {
-                TexImage4DSGIS_(target, level, internalformat, width, height, depth, size4d, border, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-
-        public static
-        void TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
-        {
-            TexSubImage4DSGIS_(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
-        }
-
-        #endregion
-
-        #region TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-
-        public static
-        void TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, object pixels)
-        {
-            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
-            try
-            {
-                TexSubImage4DSGIS_(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, IntPtr textures, IntPtr residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, IntPtr textures, IntPtr residences)
-        {
-            return AreTexturesResidentEXT_(n, textures, residences);
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, IntPtr textures, object residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, IntPtr textures, object residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreTexturesResidentEXT_(n, textures, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, IntPtr textures, GLboolean[] residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, IntPtr textures, GLboolean[] residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreTexturesResidentEXT_(n, textures, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, object textures, IntPtr residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, object textures, IntPtr residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            try
-            {
-                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), residences);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, object textures, object residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, object textures, object residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, object textures, GLboolean[] residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, object textures, GLboolean[] residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, GLuint[] textures, IntPtr residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, IntPtr residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            try
-            {
-                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), residences);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, GLuint[] textures, object residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, object residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreTexturesResidentEXT(GLsizei n, GLuint[] textures, GLboolean[] residences)
-
-        public static
-        GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, GLboolean[] residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteTexturesEXT(GLsizei n, IntPtr textures)
-
-        public static
-        void DeleteTexturesEXT(GLsizei n, IntPtr textures)
-        {
-            DeleteTexturesEXT_(n, textures);
-        }
-
-        #endregion
-
-        #region DeleteTexturesEXT(GLsizei n, object textures)
-
-        public static
-        void DeleteTexturesEXT(GLsizei n, object textures)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            try
-            {
-                DeleteTexturesEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteTexturesEXT(GLsizei n, GLuint[] textures)
-
-        public static
-        void DeleteTexturesEXT(GLsizei n, GLuint[] textures)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            try
-            {
-                DeleteTexturesEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenTexturesEXT(GLsizei n, IntPtr textures)
-
-        public static
-        void GenTexturesEXT(GLsizei n, IntPtr textures)
-        {
-            GenTexturesEXT_(n, textures);
-        }
-
-        #endregion
-
-        #region GenTexturesEXT(GLsizei n, object textures)
-
-        public static
-        void GenTexturesEXT(GLsizei n, object textures)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            try
-            {
-                GenTexturesEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenTexturesEXT(GLsizei n, GLuint[] textures)
-
-        public static
-        void GenTexturesEXT(GLsizei n, GLuint[] textures)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            try
-            {
-                GenTexturesEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, IntPtr textures, IntPtr priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, IntPtr textures, IntPtr priorities)
-        {
-            PrioritizeTexturesEXT_(n, textures, priorities);
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, IntPtr textures, object priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, IntPtr textures, object priorities)
-        {
-            GCHandle h0 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
-            try
-            {
-                PrioritizeTexturesEXT_(n, textures, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, IntPtr textures, GLclampf[] priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, IntPtr textures, GLclampf[] priorities)
-        {
-            GCHandle h0 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
-            try
-            {
-                PrioritizeTexturesEXT_(n, textures, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, object textures, IntPtr priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, object textures, IntPtr priorities)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            try
-            {
-                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), priorities);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, object textures, object priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, object textures, object priorities)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
-            try
-            {
-                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, object textures, GLclampf[] priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, object textures, GLclampf[] priorities)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
-            try
-            {
-                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, IntPtr priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, IntPtr priorities)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            try
-            {
-                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), priorities);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, object priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, object priorities)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
-            try
-            {
-                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, GLclampf[] priorities)
-
-        public static
-        void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, GLclampf[] priorities)
-        {
-            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
-            try
-            {
-                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, IntPtr points)
-
-        public static
-        void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, IntPtr points)
-        {
-            DetailTexFuncSGIS_(target, n, points);
-        }
-
-        #endregion
-
-        #region DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, object points)
-
-        public static
-        void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                DetailTexFuncSGIS_(target, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
-
-        public static
-        void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                DetailTexFuncSGIS_(target, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetDetailTexFuncSGIS(Enums.TextureTarget target, IntPtr points)
-
-        public static
-        void GetDetailTexFuncSGIS(Enums.TextureTarget target, IntPtr points)
-        {
-            GetDetailTexFuncSGIS_(target, points);
-        }
-
-        #endregion
-
-        #region GetDetailTexFuncSGIS(Enums.TextureTarget target, object points)
-
-        public static
-        void GetDetailTexFuncSGIS(Enums.TextureTarget target, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                GetDetailTexFuncSGIS_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetDetailTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
-
-        public static
-        void GetDetailTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                GetDetailTexFuncSGIS_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, IntPtr points)
-
-        public static
-        void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, IntPtr points)
-        {
-            SharpenTexFuncSGIS_(target, n, points);
-        }
-
-        #endregion
-
-        #region SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, object points)
-
-        public static
-        void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                SharpenTexFuncSGIS_(target, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
-
-        public static
-        void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                SharpenTexFuncSGIS_(target, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSharpenTexFuncSGIS(Enums.TextureTarget target, IntPtr points)
-
-        public static
-        void GetSharpenTexFuncSGIS(Enums.TextureTarget target, IntPtr points)
-        {
-            GetSharpenTexFuncSGIS_(target, points);
-        }
-
-        #endregion
-
-        #region GetSharpenTexFuncSGIS(Enums.TextureTarget target, object points)
-
-        public static
-        void GetSharpenTexFuncSGIS(Enums.TextureTarget target, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                GetSharpenTexFuncSGIS_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetSharpenTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
-
-        public static
-        void GetSharpenTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                GetSharpenTexFuncSGIS_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-
-        public static
-        void ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-        {
-            ColorPointerEXT_(size, type, stride, count, pointer);
-        }
-
-        #endregion
-
-        #region ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, object pointer)
-
-        public static
-        void ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ColorPointerEXT_(size, type, stride, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region EdgeFlagPointerEXT(GLsizei stride, GLsizei count, IntPtr pointer)
-
-        public static
-        void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, IntPtr pointer)
-        {
-            EdgeFlagPointerEXT_(stride, count, pointer);
-        }
-
-        #endregion
-
-        #region EdgeFlagPointerEXT(GLsizei stride, GLsizei count, object pointer)
-
-        public static
-        void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                EdgeFlagPointerEXT_(stride, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region EdgeFlagPointerEXT(GLsizei stride, GLsizei count, GLboolean[] pointer)
-
-        public static
-        void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, GLboolean[] pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                EdgeFlagPointerEXT_(stride, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetPointervEXT(Enums.GetPointervPName pname, IntPtr parameters)
-
-        public static
-        void GetPointervEXT(Enums.GetPointervPName pname, IntPtr parameters)
-        {
-            GetPointervEXT_(pname, parameters);
-        }
-
-        #endregion
-
-        #region GetPointervEXT(Enums.GetPointervPName pname, object parameters)
-
-        public static
-        void GetPointervEXT(Enums.GetPointervPName pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetPointervEXT_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetPointervEXT(Enums.GetPointervPName pname, IntPtr[] parameters)
-
-        public static
-        void GetPointervEXT(Enums.GetPointervPName pname, IntPtr[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetPointervEXT_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-
-        public static
-        void IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-        {
-            IndexPointerEXT_(type, stride, count, pointer);
-        }
-
-        #endregion
-
-        #region IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, object pointer)
-
-        public static
-        void IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                IndexPointerEXT_(type, stride, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-
-        public static
-        void NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-        {
-            NormalPointerEXT_(type, stride, count, pointer);
-        }
-
-        #endregion
-
-        #region NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, object pointer)
-
-        public static
-        void NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                NormalPointerEXT_(type, stride, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-
-        public static
-        void TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-        {
-            TexCoordPointerEXT_(size, type, stride, count, pointer);
-        }
-
-        #endregion
-
-        #region TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, object pointer)
-
-        public static
-        void TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                TexCoordPointerEXT_(size, type, stride, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-
-        public static
-        void VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
-        {
-            VertexPointerEXT_(size, type, stride, count, pointer);
-        }
-
-        #endregion
-
-        #region VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, object pointer)
-
-        public static
-        void VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexPointerEXT_(size, type, stride, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SpriteParameterfvSGIX(GLenum pname, IntPtr parameters)
-
-        public static
-        void SpriteParameterfvSGIX(GLenum pname, IntPtr parameters)
-        {
-            SpriteParameterfvSGIX_(pname, parameters);
-        }
-
-        #endregion
-
-        #region SpriteParameterfvSGIX(GLenum pname, object parameters)
-
-        public static
-        void SpriteParameterfvSGIX(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                SpriteParameterfvSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SpriteParameterfvSGIX(GLenum pname, GLfloat[] parameters)
-
-        public static
-        void SpriteParameterfvSGIX(GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                SpriteParameterfvSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SpriteParameterivSGIX(GLenum pname, IntPtr parameters)
-
-        public static
-        void SpriteParameterivSGIX(GLenum pname, IntPtr parameters)
-        {
-            SpriteParameterivSGIX_(pname, parameters);
-        }
-
-        #endregion
-
-        #region SpriteParameterivSGIX(GLenum pname, object parameters)
-
-        public static
-        void SpriteParameterivSGIX(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                SpriteParameterivSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SpriteParameterivSGIX(GLenum pname, GLint[] parameters)
-
-        public static
-        void SpriteParameterivSGIX(GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                SpriteParameterivSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PointParameterfvEXT(GLenum pname, IntPtr parameters)
-
-        public static
-        void PointParameterfvEXT(GLenum pname, IntPtr parameters)
-        {
-            PointParameterfvEXT_(pname, parameters);
-        }
-
-        #endregion
-
-        #region PointParameterfvEXT(GLenum pname, object parameters)
-
-        public static
-        void PointParameterfvEXT(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PointParameterfvEXT_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PointParameterfvEXT(GLenum pname, GLfloat[] parameters)
-
-        public static
-        void PointParameterfvEXT(GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PointParameterfvEXT_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PointParameterfvSGIS(GLenum pname, IntPtr parameters)
-
-        public static
-        void PointParameterfvSGIS(GLenum pname, IntPtr parameters)
-        {
-            PointParameterfvSGIS_(pname, parameters);
-        }
-
-        #endregion
-
-        #region PointParameterfvSGIS(GLenum pname, object parameters)
-
-        public static
-        void PointParameterfvSGIS(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PointParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PointParameterfvSGIS(GLenum pname, GLfloat[] parameters)
-
-        public static
-        void PointParameterfvSGIS(GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PointParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region InstrumentsBufferSGIX(GLsizei size, IntPtr buffer)
-
-        public static
-        void InstrumentsBufferSGIX(GLsizei size, IntPtr buffer)
-        {
-            InstrumentsBufferSGIX_(size, buffer);
-        }
-
-        #endregion
-
-        #region InstrumentsBufferSGIX(GLsizei size, object buffer)
-
-        public static
-        void InstrumentsBufferSGIX(GLsizei size, object buffer)
-        {
-            GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
-            try
-            {
-                InstrumentsBufferSGIX_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region InstrumentsBufferSGIX(GLsizei size, GLint[] buffer)
-
-        public static
-        void InstrumentsBufferSGIX(GLsizei size, GLint[] buffer)
-        {
-            GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
-            try
-            {
-                InstrumentsBufferSGIX_(size, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PollInstrumentsSGIX(IntPtr marker_p)
-
-        public static
-        GLint PollInstrumentsSGIX(IntPtr marker_p)
-        {
-            return PollInstrumentsSGIX_(marker_p);
-        }
-
-        #endregion
-
-        #region PollInstrumentsSGIX(object marker_p)
-
-        public static
-        GLint PollInstrumentsSGIX(object marker_p)
-        {
-            GCHandle h0 = GCHandle.Alloc(marker_p, GCHandleType.Pinned);
-            try
-            {
-                return PollInstrumentsSGIX_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PollInstrumentsSGIX(GLint[] marker_p)
-
-        public static
-        GLint PollInstrumentsSGIX(GLint[] marker_p)
-        {
-            GCHandle h0 = GCHandle.Alloc(marker_p, GCHandleType.Pinned);
-            try
-            {
-                return PollInstrumentsSGIX_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, IntPtr points)
-
-        public static
-        void DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, IntPtr points)
-        {
-            DeformationMap3dSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
-        }
-
-        #endregion
-
-        #region DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, object points)
-
-        public static
-        void DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                DeformationMap3dSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble[] points)
-
-        public static
-        void DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble[] points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                DeformationMap3dSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, IntPtr points)
-
-        public static
-        void DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, IntPtr points)
-        {
-            DeformationMap3fSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
-        }
-
-        #endregion
-
-        #region DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, object points)
-
-        public static
-        void DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                DeformationMap3fSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat[] points)
-
-        public static
-        void DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat[] points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                DeformationMap3fSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReferencePlaneSGIX(IntPtr equation)
-
-        public static
-        void ReferencePlaneSGIX(IntPtr equation)
-        {
-            ReferencePlaneSGIX_(equation);
-        }
-
-        #endregion
-
-        #region ReferencePlaneSGIX(object equation)
-
-        public static
-        void ReferencePlaneSGIX(object equation)
-        {
-            GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
-            try
-            {
-                ReferencePlaneSGIX_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReferencePlaneSGIX(GLdouble[] equation)
-
-        public static
-        void ReferencePlaneSGIX(GLdouble[] equation)
-        {
-            GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
-            try
-            {
-                ReferencePlaneSGIX_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogFuncSGIS(GLsizei n, IntPtr points)
-
-        public static
-        void FogFuncSGIS(GLsizei n, IntPtr points)
-        {
-            FogFuncSGIS_(n, points);
-        }
-
-        #endregion
-
-        #region FogFuncSGIS(GLsizei n, object points)
-
-        public static
-        void FogFuncSGIS(GLsizei n, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                FogFuncSGIS_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogFuncSGIS(GLsizei n, GLfloat[] points)
-
-        public static
-        void FogFuncSGIS(GLsizei n, GLfloat[] points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                FogFuncSGIS_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFogFuncSGIS(IntPtr points)
-
-        public static
-        void GetFogFuncSGIS(IntPtr points)
-        {
-            GetFogFuncSGIS_(points);
-        }
-
-        #endregion
-
-        #region GetFogFuncSGIS(object points)
-
-        public static
-        void GetFogFuncSGIS(object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                GetFogFuncSGIS_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFogFuncSGIS(GLfloat[] points)
-
-        public static
-        void GetFogFuncSGIS(GLfloat[] points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                GetFogFuncSGIS_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ImageTransformParameterivHP(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void ImageTransformParameterivHP(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            ImageTransformParameterivHP_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region ImageTransformParameterivHP(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void ImageTransformParameterivHP(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ImageTransformParameterivHP_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ImageTransformParameterivHP(GLenum target, GLenum pname, GLint[] parameters)
-
-        public static
-        void ImageTransformParameterivHP(GLenum target, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ImageTransformParameterivHP_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ImageTransformParameterfvHP(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void ImageTransformParameterfvHP(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            ImageTransformParameterfvHP_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region ImageTransformParameterfvHP(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void ImageTransformParameterfvHP(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ImageTransformParameterfvHP_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void ImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ImageTransformParameterfvHP_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetImageTransformParameterivHP(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetImageTransformParameterivHP(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetImageTransformParameterivHP_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetImageTransformParameterivHP(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetImageTransformParameterivHP(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetImageTransformParameterivHP_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetImageTransformParameterivHP(GLenum target, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetImageTransformParameterivHP(GLenum target, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetImageTransformParameterivHP_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetImageTransformParameterfvHP(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetImageTransformParameterfvHP(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetImageTransformParameterfvHP_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetImageTransformParameterfvHP(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetImageTransformParameterfvHP(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetImageTransformParameterfvHP_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetImageTransformParameterfvHP_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data)
-
-        public static
-        void ColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data)
-        {
-            ColorSubTableEXT_(target, start, count, format, type, data);
-        }
-
-        #endregion
-
-        #region ColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, object data)
-
-        public static
-        void ColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                ColorSubTableEXT_(target, start, count, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorTableEXT(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
-
-        public static
-        void ColorTableEXT(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
-        {
-            ColorTableEXT_(target, internalFormat, width, format, type, table);
-        }
-
-        #endregion
-
-        #region ColorTableEXT(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
-
-        public static
-        void ColorTableEXT(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
-        {
-            GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
-            try
-            {
-                ColorTableEXT_(target, internalFormat, width, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableEXT(GLenum target, Enums.PixelFormat format, Enums.PixelType type, IntPtr data)
-
-        public static
-        void GetColorTableEXT(GLenum target, Enums.PixelFormat format, Enums.PixelType type, IntPtr data)
-        {
-            GetColorTableEXT_(target, format, type, data);
-        }
-
-        #endregion
-
-        #region GetColorTableEXT(GLenum target, Enums.PixelFormat format, Enums.PixelType type, object data)
-
-        public static
-        void GetColorTableEXT(GLenum target, Enums.PixelFormat format, Enums.PixelType type, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableEXT_(target, format, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableParameterivEXT(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetColorTableParameterivEXT(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetColorTableParameterivEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetColorTableParameterivEXT(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetColorTableParameterivEXT(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableParameterivEXT(GLenum target, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetColorTableParameterivEXT(GLenum target, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableParameterfvEXT(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetColorTableParameterfvEXT(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetColorTableParameterfvEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetColorTableParameterfvEXT(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetColorTableParameterfvEXT(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetColorTableParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
-
-        public static
-        void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
-        {
-            GetListParameterfvSGIX_(list, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
-
-        public static
-        void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetListParameterfvSGIX_(list, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] parameters)
-
-        public static
-        void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetListParameterfvSGIX_(list, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
-
-        public static
-        void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
-        {
-            GetListParameterivSGIX_(list, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
-
-        public static
-        void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetListParameterivSGIX_(list, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] parameters)
-
-        public static
-        void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetListParameterivSGIX_(list, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
-
-        public static
-        void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
-        {
-            ListParameterfvSGIX_(list, pname, parameters);
-        }
-
-        #endregion
-
-        #region ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
-
-        public static
-        void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ListParameterfvSGIX_(list, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] parameters)
-
-        public static
-        void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ListParameterfvSGIX_(list, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
-
-        public static
-        void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
-        {
-            ListParameterivSGIX_(list, pname, parameters);
-        }
-
-        #endregion
-
-        #region ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
-
-        public static
-        void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ListParameterivSGIX_(list, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] parameters)
-
-        public static
-        void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ListParameterivSGIX_(list, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CullParameterdvEXT(GLenum pname, IntPtr parameters)
-
-        public static
-        void CullParameterdvEXT(GLenum pname, IntPtr parameters)
-        {
-            CullParameterdvEXT_(pname, parameters);
-        }
-
-        #endregion
-
-        #region CullParameterdvEXT(GLenum pname, object parameters)
-
-        public static
-        void CullParameterdvEXT(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CullParameterdvEXT_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CullParameterdvEXT(GLenum pname, GLdouble[] parameters)
-
-        public static
-        void CullParameterdvEXT(GLenum pname, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CullParameterdvEXT_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CullParameterfvEXT(GLenum pname, IntPtr parameters)
-
-        public static
-        void CullParameterfvEXT(GLenum pname, IntPtr parameters)
-        {
-            CullParameterfvEXT_(pname, parameters);
-        }
-
-        #endregion
-
-        #region CullParameterfvEXT(GLenum pname, object parameters)
-
-        public static
-        void CullParameterfvEXT(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CullParameterfvEXT_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CullParameterfvEXT(GLenum pname, GLfloat[] parameters)
-
-        public static
-        void CullParameterfvEXT(GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CullParameterfvEXT_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentLightfvSGIX(GLenum light, GLenum pname, IntPtr parameters)
-
-        public static
-        void FragmentLightfvSGIX(GLenum light, GLenum pname, IntPtr parameters)
-        {
-            FragmentLightfvSGIX_(light, pname, parameters);
-        }
-
-        #endregion
-
-        #region FragmentLightfvSGIX(GLenum light, GLenum pname, object parameters)
-
-        public static
-        void FragmentLightfvSGIX(GLenum light, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentLightfvSGIX_(light, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void FragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentLightfvSGIX_(light, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentLightivSGIX(GLenum light, GLenum pname, IntPtr parameters)
-
-        public static
-        void FragmentLightivSGIX(GLenum light, GLenum pname, IntPtr parameters)
-        {
-            FragmentLightivSGIX_(light, pname, parameters);
-        }
-
-        #endregion
-
-        #region FragmentLightivSGIX(GLenum light, GLenum pname, object parameters)
-
-        public static
-        void FragmentLightivSGIX(GLenum light, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentLightivSGIX_(light, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentLightivSGIX(GLenum light, GLenum pname, GLint[] parameters)
-
-        public static
-        void FragmentLightivSGIX(GLenum light, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentLightivSGIX_(light, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters)
-
-        public static
-        void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters)
-        {
-            FragmentLightModelfvSGIX_(pname, parameters);
-        }
-
-        #endregion
-
-        #region FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, object parameters)
-
-        public static
-        void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentLightModelfvSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat[] parameters)
-
-        public static
-        void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentLightModelfvSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters)
-
-        public static
-        void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters)
-        {
-            FragmentLightModelivSGIX_(pname, parameters);
-        }
-
-        #endregion
-
-        #region FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, object parameters)
-
-        public static
-        void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentLightModelivSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint[] parameters)
-
-        public static
-        void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentLightModelivSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
-
-        public static
-        void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
-        {
-            FragmentMaterialfvSGIX_(face, pname, parameters);
-        }
-
-        #endregion
-
-        #region FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
-
-        public static
-        void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentMaterialfvSGIX_(face, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] parameters)
-
-        public static
-        void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentMaterialfvSGIX_(face, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
-
-        public static
-        void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
-        {
-            FragmentMaterialivSGIX_(face, pname, parameters);
-        }
-
-        #endregion
-
-        #region FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
-
-        public static
-        void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentMaterialivSGIX_(face, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] parameters)
-
-        public static
-        void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                FragmentMaterialivSGIX_(face, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFragmentLightfvSGIX(GLenum light, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetFragmentLightfvSGIX(GLenum light, GLenum pname, IntPtr parameters)
-        {
-            GetFragmentLightfvSGIX_(light, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetFragmentLightfvSGIX(GLenum light, GLenum pname, object parameters)
-
-        public static
-        void GetFragmentLightfvSGIX(GLenum light, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFragmentLightfvSGIX_(light, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFragmentLightfvSGIX_(light, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFragmentLightivSGIX(GLenum light, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetFragmentLightivSGIX(GLenum light, GLenum pname, IntPtr parameters)
-        {
-            GetFragmentLightivSGIX_(light, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetFragmentLightivSGIX(GLenum light, GLenum pname, object parameters)
-
-        public static
-        void GetFragmentLightivSGIX(GLenum light, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFragmentLightivSGIX_(light, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFragmentLightivSGIX(GLenum light, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetFragmentLightivSGIX(GLenum light, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFragmentLightivSGIX_(light, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
-
-        public static
-        void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
-        {
-            GetFragmentMaterialfvSGIX_(face, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
-
-        public static
-        void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFragmentMaterialfvSGIX_(face, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] parameters)
-
-        public static
-        void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFragmentMaterialfvSGIX_(face, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
-
-        public static
-        void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
-        {
-            GetFragmentMaterialivSGIX_(face, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
-
-        public static
-        void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFragmentMaterialivSGIX_(face, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] parameters)
-
-        public static
-        void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFragmentMaterialivSGIX_(face, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices)
-
-        public static
-        void DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices)
-        {
-            DrawRangeElementsEXT_(mode, start, end, count, type, indices);
-        }
-
-        #endregion
-
-        #region DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, object indices)
-
-        public static
-        void DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, object indices)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                DrawRangeElementsEXT_(mode, start, end, count, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FinishAsyncSGIX(IntPtr markerp)
-
-        public static
-        GLint FinishAsyncSGIX(IntPtr markerp)
-        {
-            return FinishAsyncSGIX_(markerp);
-        }
-
-        #endregion
-
-        #region FinishAsyncSGIX(object markerp)
-
-        public static
-        GLint FinishAsyncSGIX(object markerp)
-        {
-            GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
-            try
-            {
-                return FinishAsyncSGIX_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FinishAsyncSGIX(GLuint[] markerp)
-
-        public static
-        GLint FinishAsyncSGIX(GLuint[] markerp)
-        {
-            GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
-            try
-            {
-                return FinishAsyncSGIX_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PollAsyncSGIX(IntPtr markerp)
-
-        public static
-        GLint PollAsyncSGIX(IntPtr markerp)
-        {
-            return PollAsyncSGIX_(markerp);
-        }
-
-        #endregion
-
-        #region PollAsyncSGIX(object markerp)
-
-        public static
-        GLint PollAsyncSGIX(object markerp)
-        {
-            GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
-            try
-            {
-                return PollAsyncSGIX_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PollAsyncSGIX(GLuint[] markerp)
-
-        public static
-        GLint PollAsyncSGIX(GLuint[] markerp)
-        {
-            GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
-            try
-            {
-                return PollAsyncSGIX_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
-
-        public static
-        void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
-        {
-            VertexPointervINTEL_(size, type, pointer);
-        }
-
-        #endregion
-
-        #region VertexPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
-
-        public static
-        void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexPointervINTEL_(size, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
-
-        public static
-        void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexPointervINTEL_(size, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalPointervINTEL(Enums.NormalPointerType type, IntPtr pointer)
-
-        public static
-        void NormalPointervINTEL(Enums.NormalPointerType type, IntPtr pointer)
-        {
-            NormalPointervINTEL_(type, pointer);
-        }
-
-        #endregion
-
-        #region NormalPointervINTEL(Enums.NormalPointerType type, object pointer)
-
-        public static
-        void NormalPointervINTEL(Enums.NormalPointerType type, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                NormalPointervINTEL_(type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalPointervINTEL(Enums.NormalPointerType type, IntPtr[] pointer)
-
-        public static
-        void NormalPointervINTEL(Enums.NormalPointerType type, IntPtr[] pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                NormalPointervINTEL_(type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
-
-        public static
-        void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
-        {
-            ColorPointervINTEL_(size, type, pointer);
-        }
-
-        #endregion
-
-        #region ColorPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
-
-        public static
-        void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ColorPointervINTEL_(size, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
-
-        public static
-        void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ColorPointervINTEL_(size, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
-
-        public static
-        void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
-        {
-            TexCoordPointervINTEL_(size, type, pointer);
-        }
-
-        #endregion
-
-        #region TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
-
-        public static
-        void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                TexCoordPointervINTEL_(size, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
-
-        public static
-        void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                TexCoordPointervINTEL_(size, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelTransformParameterivEXT(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void PixelTransformParameterivEXT(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            PixelTransformParameterivEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region PixelTransformParameterivEXT(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void PixelTransformParameterivEXT(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PixelTransformParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelTransformParameterivEXT(GLenum target, GLenum pname, GLint[] parameters)
-
-        public static
-        void PixelTransformParameterivEXT(GLenum target, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PixelTransformParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelTransformParameterfvEXT(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void PixelTransformParameterfvEXT(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            PixelTransformParameterfvEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region PixelTransformParameterfvEXT(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void PixelTransformParameterfvEXT(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PixelTransformParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelTransformParameterfvEXT(GLenum target, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void PixelTransformParameterfvEXT(GLenum target, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PixelTransformParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3bvEXT(IntPtr v)
-
-        public static
-        void SecondaryColor3bvEXT(IntPtr v)
-        {
-            SecondaryColor3bvEXT_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3bvEXT(object v)
-
-        public static
-        void SecondaryColor3bvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3bvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3bvEXT(GLbyte[] v)
-
-        public static
-        void SecondaryColor3bvEXT(GLbyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3bvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3dvEXT(IntPtr v)
-
-        public static
-        void SecondaryColor3dvEXT(IntPtr v)
-        {
-            SecondaryColor3dvEXT_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3dvEXT(object v)
-
-        public static
-        void SecondaryColor3dvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3dvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3dvEXT(GLdouble[] v)
-
-        public static
-        void SecondaryColor3dvEXT(GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3dvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3fvEXT(IntPtr v)
-
-        public static
-        void SecondaryColor3fvEXT(IntPtr v)
-        {
-            SecondaryColor3fvEXT_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3fvEXT(object v)
-
-        public static
-        void SecondaryColor3fvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3fvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3fvEXT(GLfloat[] v)
-
-        public static
-        void SecondaryColor3fvEXT(GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3fvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3ivEXT(IntPtr v)
-
-        public static
-        void SecondaryColor3ivEXT(IntPtr v)
-        {
-            SecondaryColor3ivEXT_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3ivEXT(object v)
-
-        public static
-        void SecondaryColor3ivEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3ivEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3ivEXT(GLint[] v)
-
-        public static
-        void SecondaryColor3ivEXT(GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3ivEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3svEXT(IntPtr v)
-
-        public static
-        void SecondaryColor3svEXT(IntPtr v)
-        {
-            SecondaryColor3svEXT_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3svEXT(object v)
-
-        public static
-        void SecondaryColor3svEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3svEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3svEXT(GLshort[] v)
-
-        public static
-        void SecondaryColor3svEXT(GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3svEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3ubvEXT(IntPtr v)
-
-        public static
-        void SecondaryColor3ubvEXT(IntPtr v)
-        {
-            SecondaryColor3ubvEXT_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3ubvEXT(object v)
-
-        public static
-        void SecondaryColor3ubvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3ubvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3ubvEXT(GLubyte[] v)
-
-        public static
-        void SecondaryColor3ubvEXT(GLubyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3ubvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3uivEXT(IntPtr v)
-
-        public static
-        void SecondaryColor3uivEXT(IntPtr v)
-        {
-            SecondaryColor3uivEXT_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3uivEXT(object v)
-
-        public static
-        void SecondaryColor3uivEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3uivEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3uivEXT(GLuint[] v)
-
-        public static
-        void SecondaryColor3uivEXT(GLuint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3uivEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3usvEXT(IntPtr v)
-
-        public static
-        void SecondaryColor3usvEXT(IntPtr v)
-        {
-            SecondaryColor3usvEXT_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3usvEXT(object v)
-
-        public static
-        void SecondaryColor3usvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3usvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3usvEXT(GLushort[] v)
-
-        public static
-        void SecondaryColor3usvEXT(GLushort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3usvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer)
-        {
-            SecondaryColorPointerEXT_(size, type, stride, pointer);
-        }
-
-        #endregion
-
-        #region SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer)
-
-        public static
-        void SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColorPointerEXT_(size, type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount)
-        {
-            MultiDrawArraysEXT_(mode, first, count, primcount);
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawArraysEXT_(mode, first, h0.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawArraysEXT_(mode, first, h0.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, object first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, object first, IntPtr count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), count, primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, object first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, object first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, object first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, object first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, IntPtr count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), count, primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount)
-        {
-            MultiDrawElementsEXT_(mode, count, type, indices, primcount);
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, object indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, object indices, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementsEXT_(mode, count, type, h0.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr[] indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr[] indices, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementsEXT_(mode, count, type, h0.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, IntPtr indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, IntPtr indices, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, indices, primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, object indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, object indices, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, IntPtr[] indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, IntPtr[] indices, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, indices, primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, IntPtr[] indices, GLsizei primcount)
-
-        public static
-        void MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, IntPtr[] indices, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoordfvEXT(IntPtr coord)
-
-        public static
-        void FogCoordfvEXT(IntPtr coord)
-        {
-            FogCoordfvEXT_(coord);
-        }
-
-        #endregion
-
-        #region FogCoordfvEXT(object coord)
-
-        public static
-        void FogCoordfvEXT(object coord)
-        {
-            GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
-            try
-            {
-                FogCoordfvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoordfvEXT(GLfloat[] coord)
-
-        public static
-        void FogCoordfvEXT(GLfloat[] coord)
-        {
-            GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
-            try
-            {
-                FogCoordfvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoorddvEXT(IntPtr coord)
-
-        public static
-        void FogCoorddvEXT(IntPtr coord)
-        {
-            FogCoorddvEXT_(coord);
-        }
-
-        #endregion
-
-        #region FogCoorddvEXT(object coord)
-
-        public static
-        void FogCoorddvEXT(object coord)
-        {
-            GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
-            try
-            {
-                FogCoorddvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoorddvEXT(GLdouble[] coord)
-
-        public static
-        void FogCoorddvEXT(GLdouble[] coord)
-        {
-            GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
-            try
-            {
-                FogCoorddvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoordPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void FogCoordPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
-        {
-            FogCoordPointerEXT_(type, stride, pointer);
-        }
-
-        #endregion
-
-        #region FogCoordPointerEXT(GLenum type, GLsizei stride, object pointer)
-
-        public static
-        void FogCoordPointerEXT(GLenum type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                FogCoordPointerEXT_(type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3bvEXT(IntPtr v)
-
-        public static
-        void Tangent3bvEXT(IntPtr v)
-        {
-            Tangent3bvEXT_(v);
-        }
-
-        #endregion
-
-        #region Tangent3bvEXT(object v)
-
-        public static
-        void Tangent3bvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3bvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3bvEXT(GLbyte[] v)
-
-        public static
-        void Tangent3bvEXT(GLbyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3bvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3dvEXT(IntPtr v)
-
-        public static
-        void Tangent3dvEXT(IntPtr v)
-        {
-            Tangent3dvEXT_(v);
-        }
-
-        #endregion
-
-        #region Tangent3dvEXT(object v)
-
-        public static
-        void Tangent3dvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3dvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3dvEXT(GLdouble[] v)
-
-        public static
-        void Tangent3dvEXT(GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3dvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3fvEXT(IntPtr v)
-
-        public static
-        void Tangent3fvEXT(IntPtr v)
-        {
-            Tangent3fvEXT_(v);
-        }
-
-        #endregion
-
-        #region Tangent3fvEXT(object v)
-
-        public static
-        void Tangent3fvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3fvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3fvEXT(GLfloat[] v)
-
-        public static
-        void Tangent3fvEXT(GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3fvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3ivEXT(IntPtr v)
-
-        public static
-        void Tangent3ivEXT(IntPtr v)
-        {
-            Tangent3ivEXT_(v);
-        }
-
-        #endregion
-
-        #region Tangent3ivEXT(object v)
-
-        public static
-        void Tangent3ivEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3ivEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3ivEXT(GLint[] v)
-
-        public static
-        void Tangent3ivEXT(GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3ivEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3svEXT(IntPtr v)
-
-        public static
-        void Tangent3svEXT(IntPtr v)
-        {
-            Tangent3svEXT_(v);
-        }
-
-        #endregion
-
-        #region Tangent3svEXT(object v)
-
-        public static
-        void Tangent3svEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3svEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Tangent3svEXT(GLshort[] v)
-
-        public static
-        void Tangent3svEXT(GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Tangent3svEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3bvEXT(IntPtr v)
-
-        public static
-        void Binormal3bvEXT(IntPtr v)
-        {
-            Binormal3bvEXT_(v);
-        }
-
-        #endregion
-
-        #region Binormal3bvEXT(object v)
-
-        public static
-        void Binormal3bvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3bvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3bvEXT(GLbyte[] v)
-
-        public static
-        void Binormal3bvEXT(GLbyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3bvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3dvEXT(IntPtr v)
-
-        public static
-        void Binormal3dvEXT(IntPtr v)
-        {
-            Binormal3dvEXT_(v);
-        }
-
-        #endregion
-
-        #region Binormal3dvEXT(object v)
-
-        public static
-        void Binormal3dvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3dvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3dvEXT(GLdouble[] v)
-
-        public static
-        void Binormal3dvEXT(GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3dvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3fvEXT(IntPtr v)
-
-        public static
-        void Binormal3fvEXT(IntPtr v)
-        {
-            Binormal3fvEXT_(v);
-        }
-
-        #endregion
-
-        #region Binormal3fvEXT(object v)
-
-        public static
-        void Binormal3fvEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3fvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3fvEXT(GLfloat[] v)
-
-        public static
-        void Binormal3fvEXT(GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3fvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3ivEXT(IntPtr v)
-
-        public static
-        void Binormal3ivEXT(IntPtr v)
-        {
-            Binormal3ivEXT_(v);
-        }
-
-        #endregion
-
-        #region Binormal3ivEXT(object v)
-
-        public static
-        void Binormal3ivEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3ivEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3ivEXT(GLint[] v)
-
-        public static
-        void Binormal3ivEXT(GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3ivEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3svEXT(IntPtr v)
-
-        public static
-        void Binormal3svEXT(IntPtr v)
-        {
-            Binormal3svEXT_(v);
-        }
-
-        #endregion
-
-        #region Binormal3svEXT(object v)
-
-        public static
-        void Binormal3svEXT(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3svEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Binormal3svEXT(GLshort[] v)
-
-        public static
-        void Binormal3svEXT(GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Binormal3svEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TangentPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void TangentPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
-        {
-            TangentPointerEXT_(type, stride, pointer);
-        }
-
-        #endregion
-
-        #region TangentPointerEXT(GLenum type, GLsizei stride, object pointer)
-
-        public static
-        void TangentPointerEXT(GLenum type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                TangentPointerEXT_(type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region BinormalPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void BinormalPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
-        {
-            BinormalPointerEXT_(type, stride, pointer);
-        }
-
-        #endregion
-
-        #region BinormalPointerEXT(GLenum type, GLsizei stride, object pointer)
-
-        public static
-        void BinormalPointerEXT(GLenum type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                BinormalPointerEXT_(type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuivSUN(IntPtr code)
-
-        public static
-        void ReplacementCodeuivSUN(IntPtr code)
-        {
-            ReplacementCodeuivSUN_(code);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuivSUN(object code)
-
-        public static
-        void ReplacementCodeuivSUN(object code)
-        {
-            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuivSUN_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuivSUN(GLuint[] code)
-
-        public static
-        void ReplacementCodeuivSUN(GLuint[] code)
-        {
-            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuivSUN_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeusvSUN(IntPtr code)
-
-        public static
-        void ReplacementCodeusvSUN(IntPtr code)
-        {
-            ReplacementCodeusvSUN_(code);
-        }
-
-        #endregion
-
-        #region ReplacementCodeusvSUN(object code)
-
-        public static
-        void ReplacementCodeusvSUN(object code)
-        {
-            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeusvSUN_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeusvSUN(GLushort[] code)
-
-        public static
-        void ReplacementCodeusvSUN(GLushort[] code)
-        {
-            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeusvSUN_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeubvSUN(IntPtr code)
-
-        public static
-        void ReplacementCodeubvSUN(IntPtr code)
-        {
-            ReplacementCodeubvSUN_(code);
-        }
-
-        #endregion
-
-        #region ReplacementCodeubvSUN(object code)
-
-        public static
-        void ReplacementCodeubvSUN(object code)
-        {
-            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeubvSUN_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeubvSUN(GLubyte[] code)
-
-        public static
-        void ReplacementCodeubvSUN(GLubyte[] code)
-        {
-            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeubvSUN_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodePointerSUN(GLenum type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void ReplacementCodePointerSUN(GLenum type, GLsizei stride, IntPtr pointer)
-        {
-            ReplacementCodePointerSUN_(type, stride, pointer);
-        }
-
-        #endregion
-
-        #region ReplacementCodePointerSUN(GLenum type, GLsizei stride, object pointer)
-
-        public static
-        void ReplacementCodePointerSUN(GLenum type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodePointerSUN_(type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodePointerSUN(GLenum type, GLsizei stride, IntPtr[] pointer)
-
-        public static
-        void ReplacementCodePointerSUN(GLenum type, GLsizei stride, IntPtr[] pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodePointerSUN_(type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(IntPtr c, IntPtr v)
-
-        public static
-        void Color4ubVertex2fvSUN(IntPtr c, IntPtr v)
-        {
-            Color4ubVertex2fvSUN_(c, v);
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(IntPtr c, object v)
-
-        public static
-        void Color4ubVertex2fvSUN(IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex2fvSUN_(c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(IntPtr c, GLfloat[] v)
-
-        public static
-        void Color4ubVertex2fvSUN(IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex2fvSUN_(c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(object c, IntPtr v)
-
-        public static
-        void Color4ubVertex2fvSUN(object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(object c, object v)
-
-        public static
-        void Color4ubVertex2fvSUN(object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(object c, GLfloat[] v)
-
-        public static
-        void Color4ubVertex2fvSUN(object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(GLubyte[] c, IntPtr v)
-
-        public static
-        void Color4ubVertex2fvSUN(GLubyte[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(GLubyte[] c, object v)
-
-        public static
-        void Color4ubVertex2fvSUN(GLubyte[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex2fvSUN(GLubyte[] c, GLfloat[] v)
-
-        public static
-        void Color4ubVertex2fvSUN(GLubyte[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(IntPtr c, IntPtr v)
-
-        public static
-        void Color4ubVertex3fvSUN(IntPtr c, IntPtr v)
-        {
-            Color4ubVertex3fvSUN_(c, v);
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(IntPtr c, object v)
-
-        public static
-        void Color4ubVertex3fvSUN(IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex3fvSUN_(c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(IntPtr c, GLfloat[] v)
-
-        public static
-        void Color4ubVertex3fvSUN(IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex3fvSUN_(c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(object c, IntPtr v)
-
-        public static
-        void Color4ubVertex3fvSUN(object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(object c, object v)
-
-        public static
-        void Color4ubVertex3fvSUN(object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(object c, GLfloat[] v)
-
-        public static
-        void Color4ubVertex3fvSUN(object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(GLubyte[] c, IntPtr v)
-
-        public static
-        void Color4ubVertex3fvSUN(GLubyte[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(GLubyte[] c, object v)
-
-        public static
-        void Color4ubVertex3fvSUN(GLubyte[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4ubVertex3fvSUN(GLubyte[] c, GLfloat[] v)
-
-        public static
-        void Color4ubVertex3fvSUN(GLubyte[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(IntPtr c, IntPtr v)
-
-        public static
-        void Color3fVertex3fvSUN(IntPtr c, IntPtr v)
-        {
-            Color3fVertex3fvSUN_(c, v);
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(IntPtr c, object v)
-
-        public static
-        void Color3fVertex3fvSUN(IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color3fVertex3fvSUN_(c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(IntPtr c, GLfloat[] v)
-
-        public static
-        void Color3fVertex3fvSUN(IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color3fVertex3fvSUN_(c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(object c, IntPtr v)
-
-        public static
-        void Color3fVertex3fvSUN(object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(object c, object v)
-
-        public static
-        void Color3fVertex3fvSUN(object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(object c, GLfloat[] v)
-
-        public static
-        void Color3fVertex3fvSUN(object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(GLfloat[] c, IntPtr v)
-
-        public static
-        void Color3fVertex3fvSUN(GLfloat[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(GLfloat[] c, object v)
-
-        public static
-        void Color3fVertex3fvSUN(GLfloat[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3fVertex3fvSUN(GLfloat[] c, GLfloat[] v)
-
-        public static
-        void Color3fVertex3fvSUN(GLfloat[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(IntPtr n, IntPtr v)
-
-        public static
-        void Normal3fVertex3fvSUN(IntPtr n, IntPtr v)
-        {
-            Normal3fVertex3fvSUN_(n, v);
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(IntPtr n, object v)
-
-        public static
-        void Normal3fVertex3fvSUN(IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Normal3fVertex3fvSUN_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(IntPtr n, GLfloat[] v)
-
-        public static
-        void Normal3fVertex3fvSUN(IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Normal3fVertex3fvSUN_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(object n, IntPtr v)
-
-        public static
-        void Normal3fVertex3fvSUN(object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(object n, object v)
-
-        public static
-        void Normal3fVertex3fvSUN(object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(object n, GLfloat[] v)
-
-        public static
-        void Normal3fVertex3fvSUN(object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(GLfloat[] n, IntPtr v)
-
-        public static
-        void Normal3fVertex3fvSUN(GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(GLfloat[] n, object v)
-
-        public static
-        void Normal3fVertex3fvSUN(GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3fVertex3fvSUN(GLfloat[] n, GLfloat[] v)
-
-        public static
-        void Normal3fVertex3fvSUN(GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, IntPtr v)
-        {
-            Color4fNormal3fVertex3fvSUN_(c, n, v);
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, object n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, object n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, IntPtr n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, IntPtr n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, object n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, object n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, object n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(IntPtr tc, IntPtr v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(IntPtr tc, IntPtr v)
-        {
-            TexCoord2fVertex3fvSUN_(tc, v);
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(IntPtr tc, object v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(IntPtr tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fVertex3fvSUN_(tc, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(IntPtr tc, GLfloat[] v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(IntPtr tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fVertex3fvSUN_(tc, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(object tc, IntPtr v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(object tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(object tc, object v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(object tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(object tc, GLfloat[] v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(object tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(GLfloat[] tc, IntPtr v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(GLfloat[] tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(GLfloat[] tc, object v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(GLfloat[] tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fVertex3fvSUN(GLfloat[] tc, GLfloat[] v)
-
-        public static
-        void TexCoord2fVertex3fvSUN(GLfloat[] tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(IntPtr tc, IntPtr v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(IntPtr tc, IntPtr v)
-        {
-            TexCoord4fVertex4fvSUN_(tc, v);
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(IntPtr tc, object v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(IntPtr tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fVertex4fvSUN_(tc, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(IntPtr tc, GLfloat[] v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(IntPtr tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fVertex4fvSUN_(tc, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(object tc, IntPtr v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(object tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(object tc, object v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(object tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(object tc, GLfloat[] v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(object tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(GLfloat[] tc, IntPtr v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(GLfloat[] tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(GLfloat[] tc, object v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(GLfloat[] tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fVertex4fvSUN(GLfloat[] tc, GLfloat[] v)
-
-        public static
-        void TexCoord4fVertex4fvSUN(GLfloat[] tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
-        {
-            TexCoord2fColor4ubVertex3fvSUN_(tc, c, v);
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, object c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, object c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, object c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, IntPtr v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, object v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
-        {
-            TexCoord2fColor3fVertex3fvSUN_(tc, c, v);
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, object c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, object c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, object c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, IntPtr v)
-        {
-            TexCoord2fNormal3fVertex3fvSUN_(tc, n, v);
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(tc, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(tc, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, object n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, object n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, n, v);
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, n, v);
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(IntPtr rc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(IntPtr rc, IntPtr v)
-        {
-            ReplacementCodeuiVertex3fvSUN_(rc, v);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(IntPtr rc, object v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(IntPtr rc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiVertex3fvSUN_(rc, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(IntPtr rc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(IntPtr rc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiVertex3fvSUN_(rc, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(object rc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(object rc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(object rc, object v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(object rc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(object rc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(object rc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(GLuint[] rc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(GLuint[] rc, object v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiVertex3fvSUN(GLuint[] rc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
-        {
-            ReplacementCodeuiColor4ubVertex3fvSUN_(rc, c, v);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, object v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
-        {
-            ReplacementCodeuiColor3fVertex3fvSUN_(rc, c, v);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, IntPtr v)
-        {
-            ReplacementCodeuiNormal3fVertex3fvSUN_(rc, n, v);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, n, v);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr v)
-        {
-            ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, tc, v);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, IntPtr v)
-        {
-            ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, n, v);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, n, v);
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-
-        public static
-        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
-            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
-            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h4.Free();
-                h3.Free();
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexWeightfvEXT(IntPtr weight)
-
-        public static
-        void VertexWeightfvEXT(IntPtr weight)
-        {
-            VertexWeightfvEXT_(weight);
-        }
-
-        #endregion
-
-        #region VertexWeightfvEXT(object weight)
-
-        public static
-        void VertexWeightfvEXT(object weight)
-        {
-            GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
-            try
-            {
-                VertexWeightfvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexWeightfvEXT(GLfloat[] weight)
-
-        public static
-        void VertexWeightfvEXT(GLfloat[] weight)
-        {
-            GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
-            try
-            {
-                VertexWeightfvEXT_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void VertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, IntPtr pointer)
-        {
-            VertexWeightPointerEXT_(size, type, stride, pointer);
-        }
-
-        #endregion
-
-        #region VertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, object pointer)
-
-        public static
-        void VertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexWeightPointerEXT_(size, type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexArrayRangeNV(GLsizei length, IntPtr pointer)
-
-        public static
-        void VertexArrayRangeNV(GLsizei length, IntPtr pointer)
-        {
-            VertexArrayRangeNV_(length, pointer);
-        }
-
-        #endregion
-
-        #region VertexArrayRangeNV(GLsizei length, object pointer)
-
-        public static
-        void VertexArrayRangeNV(GLsizei length, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexArrayRangeNV_(length, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CombinerParameterfvNV(GLenum pname, IntPtr parameters)
-
-        public static
-        void CombinerParameterfvNV(GLenum pname, IntPtr parameters)
-        {
-            CombinerParameterfvNV_(pname, parameters);
-        }
-
-        #endregion
-
-        #region CombinerParameterfvNV(GLenum pname, object parameters)
-
-        public static
-        void CombinerParameterfvNV(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CombinerParameterfvNV_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CombinerParameterfvNV(GLenum pname, GLfloat[] parameters)
-
-        public static
-        void CombinerParameterfvNV(GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CombinerParameterfvNV_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CombinerParameterivNV(GLenum pname, IntPtr parameters)
-
-        public static
-        void CombinerParameterivNV(GLenum pname, IntPtr parameters)
-        {
-            CombinerParameterivNV_(pname, parameters);
-        }
-
-        #endregion
-
-        #region CombinerParameterivNV(GLenum pname, object parameters)
-
-        public static
-        void CombinerParameterivNV(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CombinerParameterivNV_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CombinerParameterivNV(GLenum pname, GLint[] parameters)
-
-        public static
-        void CombinerParameterivNV(GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CombinerParameterivNV_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters)
-        {
-            GetCombinerInputParameterfvNV_(stage, portion, variable, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, object parameters)
-
-        public static
-        void GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerInputParameterfvNV_(stage, portion, variable, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerInputParameterfvNV_(stage, portion, variable, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters)
-        {
-            GetCombinerInputParameterivNV_(stage, portion, variable, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, object parameters)
-
-        public static
-        void GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerInputParameterivNV_(stage, portion, variable, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerInputParameterivNV_(stage, portion, variable, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters)
-        {
-            GetCombinerOutputParameterfvNV_(stage, portion, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, object parameters)
-
-        public static
-        void GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerOutputParameterfvNV_(stage, portion, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerOutputParameterfvNV_(stage, portion, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters)
-        {
-            GetCombinerOutputParameterivNV_(stage, portion, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, object parameters)
-
-        public static
-        void GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerOutputParameterivNV_(stage, portion, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerOutputParameterivNV_(stage, portion, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, IntPtr parameters)
-        {
-            GetFinalCombinerInputParameterfvNV_(variable, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, object parameters)
-
-        public static
-        void GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFinalCombinerInputParameterfvNV_(variable, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFinalCombinerInputParameterfvNV_(variable, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, IntPtr parameters)
-        {
-            GetFinalCombinerInputParameterivNV_(variable, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, object parameters)
-
-        public static
-        void GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFinalCombinerInputParameterivNV_(variable, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFinalCombinerInputParameterivNV_(variable, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2dvMESA(IntPtr v)
-
-        public static
-        void WindowPos2dvMESA(IntPtr v)
-        {
-            WindowPos2dvMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos2dvMESA(object v)
-
-        public static
-        void WindowPos2dvMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2dvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2dvMESA(GLdouble[] v)
-
-        public static
-        void WindowPos2dvMESA(GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2dvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2fvMESA(IntPtr v)
-
-        public static
-        void WindowPos2fvMESA(IntPtr v)
-        {
-            WindowPos2fvMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos2fvMESA(object v)
-
-        public static
-        void WindowPos2fvMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2fvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2fvMESA(GLfloat[] v)
-
-        public static
-        void WindowPos2fvMESA(GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2fvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2ivMESA(IntPtr v)
-
-        public static
-        void WindowPos2ivMESA(IntPtr v)
-        {
-            WindowPos2ivMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos2ivMESA(object v)
-
-        public static
-        void WindowPos2ivMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2ivMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2ivMESA(GLint[] v)
-
-        public static
-        void WindowPos2ivMESA(GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2ivMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2svMESA(IntPtr v)
-
-        public static
-        void WindowPos2svMESA(IntPtr v)
-        {
-            WindowPos2svMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos2svMESA(object v)
-
-        public static
-        void WindowPos2svMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2svMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos2svMESA(GLshort[] v)
-
-        public static
-        void WindowPos2svMESA(GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos2svMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3dvMESA(IntPtr v)
-
-        public static
-        void WindowPos3dvMESA(IntPtr v)
-        {
-            WindowPos3dvMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos3dvMESA(object v)
-
-        public static
-        void WindowPos3dvMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3dvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3dvMESA(GLdouble[] v)
-
-        public static
-        void WindowPos3dvMESA(GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3dvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3fvMESA(IntPtr v)
-
-        public static
-        void WindowPos3fvMESA(IntPtr v)
-        {
-            WindowPos3fvMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos3fvMESA(object v)
-
-        public static
-        void WindowPos3fvMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3fvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3fvMESA(GLfloat[] v)
-
-        public static
-        void WindowPos3fvMESA(GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3fvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3ivMESA(IntPtr v)
-
-        public static
-        void WindowPos3ivMESA(IntPtr v)
-        {
-            WindowPos3ivMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos3ivMESA(object v)
-
-        public static
-        void WindowPos3ivMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3ivMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3ivMESA(GLint[] v)
-
-        public static
-        void WindowPos3ivMESA(GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3ivMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3svMESA(IntPtr v)
-
-        public static
-        void WindowPos3svMESA(IntPtr v)
-        {
-            WindowPos3svMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos3svMESA(object v)
-
-        public static
-        void WindowPos3svMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3svMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos3svMESA(GLshort[] v)
-
-        public static
-        void WindowPos3svMESA(GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos3svMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos4dvMESA(IntPtr v)
-
-        public static
-        void WindowPos4dvMESA(IntPtr v)
-        {
-            WindowPos4dvMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos4dvMESA(object v)
-
-        public static
-        void WindowPos4dvMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos4dvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos4dvMESA(GLdouble[] v)
-
-        public static
-        void WindowPos4dvMESA(GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos4dvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos4fvMESA(IntPtr v)
-
-        public static
-        void WindowPos4fvMESA(IntPtr v)
-        {
-            WindowPos4fvMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos4fvMESA(object v)
-
-        public static
-        void WindowPos4fvMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos4fvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos4fvMESA(GLfloat[] v)
-
-        public static
-        void WindowPos4fvMESA(GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos4fvMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos4ivMESA(IntPtr v)
-
-        public static
-        void WindowPos4ivMESA(IntPtr v)
-        {
-            WindowPos4ivMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos4ivMESA(object v)
-
-        public static
-        void WindowPos4ivMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos4ivMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos4ivMESA(GLint[] v)
-
-        public static
-        void WindowPos4ivMESA(GLint[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos4ivMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos4svMESA(IntPtr v)
-
-        public static
-        void WindowPos4svMESA(IntPtr v)
-        {
-            WindowPos4svMESA_(v);
-        }
-
-        #endregion
-
-        #region WindowPos4svMESA(object v)
-
-        public static
-        void WindowPos4svMESA(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos4svMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region WindowPos4svMESA(GLshort[] v)
-
-        public static
-        void WindowPos4svMESA(GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                WindowPos4svMESA_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            MultiModeDrawArraysIBM_(mode, first, count, primcount, modestride);
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(mode, first, h0.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(mode, first, h0.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), count, primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, object first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, object first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), count, primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, count, primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, object first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, object first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(object mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(object mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, count, primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(IntPtr mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(IntPtr mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            MultiModeDrawElementsIBM_(mode, count, type, indices, primcount, modestride);
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(IntPtr mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(IntPtr mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(mode, count, type, h0.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(IntPtr mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(IntPtr mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(mode, h0.AddrOfPinnedObject(), type, indices, primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(IntPtr mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(IntPtr mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(IntPtr mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(IntPtr mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(mode, h0.AddrOfPinnedObject(), type, indices, primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(IntPtr mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(IntPtr mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(object mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(object mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), count, type, indices, primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(object mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(object mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), count, type, h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(object mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(object mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(object mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(object mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(object mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(object mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(object mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(object mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), count, type, indices, primcount, modestride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), count, type, h1.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-
-        public static
-        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
-        {
-            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
-            try
-            {
-                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
-            }
-            finally
-            {
-                h2.Free();
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-
-        public static
-        void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-        {
-            ColorPointerListIBM_(size, type, stride, pointer, ptrstride);
-        }
-
-        #endregion
-
-        #region ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, object pointer, GLint ptrstride)
-
-        public static
-        void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, object pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ColorPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-
-        public static
-        void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ColorPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, IntPtr pointer, GLint ptrstride)
-
-        public static
-        void SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, IntPtr pointer, GLint ptrstride)
-        {
-            SecondaryColorPointerListIBM_(size, type, stride, pointer, ptrstride);
-        }
-
-        #endregion
-
-        #region SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, object pointer, GLint ptrstride)
-
-        public static
-        void SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, object pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColorPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-
-        public static
-        void SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColorPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region EdgeFlagPointerListIBM(GLint stride, IntPtr pointer, GLint ptrstride)
-
-        public static
-        void EdgeFlagPointerListIBM(GLint stride, IntPtr pointer, GLint ptrstride)
-        {
-            EdgeFlagPointerListIBM_(stride, pointer, ptrstride);
-        }
-
-        #endregion
-
-        #region EdgeFlagPointerListIBM(GLint stride, object pointer, GLint ptrstride)
-
-        public static
-        void EdgeFlagPointerListIBM(GLint stride, object pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                EdgeFlagPointerListIBM_(stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region EdgeFlagPointerListIBM(GLint stride, GLboolean[] pointer, GLint ptrstride)
-
-        public static
-        void EdgeFlagPointerListIBM(GLint stride, GLboolean[] pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                EdgeFlagPointerListIBM_(stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoordPointerListIBM(GLenum type, GLint stride, IntPtr pointer, GLint ptrstride)
-
-        public static
-        void FogCoordPointerListIBM(GLenum type, GLint stride, IntPtr pointer, GLint ptrstride)
-        {
-            FogCoordPointerListIBM_(type, stride, pointer, ptrstride);
-        }
-
-        #endregion
-
-        #region FogCoordPointerListIBM(GLenum type, GLint stride, object pointer, GLint ptrstride)
-
-        public static
-        void FogCoordPointerListIBM(GLenum type, GLint stride, object pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                FogCoordPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoordPointerListIBM(GLenum type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-
-        public static
-        void FogCoordPointerListIBM(GLenum type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                FogCoordPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-
-        public static
-        void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-        {
-            IndexPointerListIBM_(type, stride, pointer, ptrstride);
-        }
-
-        #endregion
-
-        #region IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, object pointer, GLint ptrstride)
-
-        public static
-        void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, object pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                IndexPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-
-        public static
-        void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                IndexPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-
-        public static
-        void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-        {
-            NormalPointerListIBM_(type, stride, pointer, ptrstride);
-        }
-
-        #endregion
-
-        #region NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, object pointer, GLint ptrstride)
-
-        public static
-        void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, object pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                NormalPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-
-        public static
-        void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                NormalPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-
-        public static
-        void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-        {
-            TexCoordPointerListIBM_(size, type, stride, pointer, ptrstride);
-        }
-
-        #endregion
-
-        #region TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, object pointer, GLint ptrstride)
-
-        public static
-        void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, object pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                TexCoordPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-
-        public static
-        void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                TexCoordPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-
-        public static
-        void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
-        {
-            VertexPointerListIBM_(size, type, stride, pointer, ptrstride);
-        }
-
-        #endregion
-
-        #region VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, object pointer, GLint ptrstride)
-
-        public static
-        void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, object pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-
-        public static
-        void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region IglooInterfaceSGIX(GLenum pname, IntPtr parameters)
-
-        public static
-        void IglooInterfaceSGIX(GLenum pname, IntPtr parameters)
-        {
-            IglooInterfaceSGIX_(pname, parameters);
-        }
-
-        #endregion
-
-        #region IglooInterfaceSGIX(GLenum pname, object parameters)
-
-        public static
-        void IglooInterfaceSGIX(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                IglooInterfaceSGIX_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteFencesNV(GLsizei n, IntPtr fences)
-
-        public static
-        void DeleteFencesNV(GLsizei n, IntPtr fences)
-        {
-            DeleteFencesNV_(n, fences);
-        }
-
-        #endregion
-
-        #region DeleteFencesNV(GLsizei n, object fences)
-
-        public static
-        void DeleteFencesNV(GLsizei n, object fences)
-        {
-            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
-            try
-            {
-                DeleteFencesNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteFencesNV(GLsizei n, GLuint[] fences)
-
-        public static
-        void DeleteFencesNV(GLsizei n, GLuint[] fences)
-        {
-            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
-            try
-            {
-                DeleteFencesNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenFencesNV(GLsizei n, IntPtr fences)
-
-        public static
-        void GenFencesNV(GLsizei n, IntPtr fences)
-        {
-            GenFencesNV_(n, fences);
-        }
-
-        #endregion
-
-        #region GenFencesNV(GLsizei n, object fences)
-
-        public static
-        void GenFencesNV(GLsizei n, object fences)
-        {
-            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
-            try
-            {
-                GenFencesNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenFencesNV(GLsizei n, GLuint[] fences)
-
-        public static
-        void GenFencesNV(GLsizei n, GLuint[] fences)
-        {
-            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
-            try
-            {
-                GenFencesNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFenceivNV(GLuint fence, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetFenceivNV(GLuint fence, GLenum pname, IntPtr parameters)
-        {
-            GetFenceivNV_(fence, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetFenceivNV(GLuint fence, GLenum pname, object parameters)
-
-        public static
-        void GetFenceivNV(GLuint fence, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFenceivNV_(fence, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFenceivNV(GLuint fence, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetFenceivNV(GLuint fence, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFenceivNV_(fence, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, IntPtr points)
-
-        public static
-        void MapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, IntPtr points)
-        {
-            MapControlPointsNV_(target, index, type, ustride, vstride, uorder, vorder, packed, points);
-        }
-
-        #endregion
-
-        #region MapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, object points)
-
-        public static
-        void MapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                MapControlPointsNV_(target, index, type, ustride, vstride, uorder, vorder, packed, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MapParameterivNV(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void MapParameterivNV(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            MapParameterivNV_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region MapParameterivNV(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void MapParameterivNV(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                MapParameterivNV_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MapParameterivNV(GLenum target, GLenum pname, GLint[] parameters)
-
-        public static
-        void MapParameterivNV(GLenum target, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                MapParameterivNV_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MapParameterfvNV(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void MapParameterfvNV(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            MapParameterfvNV_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region MapParameterfvNV(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void MapParameterfvNV(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                MapParameterfvNV_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MapParameterfvNV(GLenum target, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void MapParameterfvNV(GLenum target, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                MapParameterfvNV_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, IntPtr points)
-
-        public static
-        void GetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, IntPtr points)
-        {
-            GetMapControlPointsNV_(target, index, type, ustride, vstride, packed, points);
-        }
-
-        #endregion
-
-        #region GetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, object points)
-
-        public static
-        void GetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, object points)
-        {
-            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
-            try
-            {
-                GetMapControlPointsNV_(target, index, type, ustride, vstride, packed, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapParameterivNV(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetMapParameterivNV(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetMapParameterivNV_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetMapParameterivNV(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetMapParameterivNV(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMapParameterivNV_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapParameterivNV(GLenum target, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetMapParameterivNV(GLenum target, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMapParameterivNV_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapParameterfvNV(GLenum target, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetMapParameterfvNV(GLenum target, GLenum pname, IntPtr parameters)
-        {
-            GetMapParameterfvNV_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetMapParameterfvNV(GLenum target, GLenum pname, object parameters)
-
-        public static
-        void GetMapParameterfvNV(GLenum target, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMapParameterfvNV_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapParameterfvNV(GLenum target, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetMapParameterfvNV(GLenum target, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMapParameterfvNV_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetMapAttribParameterivNV_(target, index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMapAttribParameterivNV_(target, index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMapAttribParameterivNV_(target, index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetMapAttribParameterfvNV_(target, index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMapAttribParameterfvNV_(target, index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetMapAttribParameterfvNV_(target, index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CombinerStageParameterfvNV(GLenum stage, GLenum pname, IntPtr parameters)
-
-        public static
-        void CombinerStageParameterfvNV(GLenum stage, GLenum pname, IntPtr parameters)
-        {
-            CombinerStageParameterfvNV_(stage, pname, parameters);
-        }
-
-        #endregion
-
-        #region CombinerStageParameterfvNV(GLenum stage, GLenum pname, object parameters)
-
-        public static
-        void CombinerStageParameterfvNV(GLenum stage, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CombinerStageParameterfvNV_(stage, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region CombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void CombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                CombinerStageParameterfvNV_(stage, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, IntPtr parameters)
-        {
-            GetCombinerStageParameterfvNV_(stage, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, object parameters)
-
-        public static
-        void GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerStageParameterfvNV_(stage, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetCombinerStageParameterfvNV_(stage, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, IntPtr programs, IntPtr residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, IntPtr programs, IntPtr residences)
-        {
-            return AreProgramsResidentNV_(n, programs, residences);
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, IntPtr programs, object residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, IntPtr programs, object residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreProgramsResidentNV_(n, programs, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, IntPtr programs, GLboolean[] residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, IntPtr programs, GLboolean[] residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreProgramsResidentNV_(n, programs, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, object programs, IntPtr residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, object programs, IntPtr residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), residences);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, object programs, object residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, object programs, object residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, object programs, GLboolean[] residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, object programs, GLboolean[] residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, GLuint[] programs, IntPtr residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, IntPtr residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), residences);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, GLuint[] programs, object residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, object residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region AreProgramsResidentNV(GLsizei n, GLuint[] programs, GLboolean[] residences)
-
-        public static
-        GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, GLboolean[] residences)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
-            try
-            {
-                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteProgramsNV(GLsizei n, IntPtr programs)
-
-        public static
-        void DeleteProgramsNV(GLsizei n, IntPtr programs)
-        {
-            DeleteProgramsNV_(n, programs);
-        }
-
-        #endregion
-
-        #region DeleteProgramsNV(GLsizei n, object programs)
-
-        public static
-        void DeleteProgramsNV(GLsizei n, object programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                DeleteProgramsNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteProgramsNV(GLsizei n, GLuint[] programs)
-
-        public static
-        void DeleteProgramsNV(GLsizei n, GLuint[] programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                DeleteProgramsNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ExecuteProgramNV(GLenum target, GLuint id, IntPtr parameters)
-
-        public static
-        void ExecuteProgramNV(GLenum target, GLuint id, IntPtr parameters)
-        {
-            ExecuteProgramNV_(target, id, parameters);
-        }
-
-        #endregion
-
-        #region ExecuteProgramNV(GLenum target, GLuint id, object parameters)
-
-        public static
-        void ExecuteProgramNV(GLenum target, GLuint id, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ExecuteProgramNV_(target, id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ExecuteProgramNV(GLenum target, GLuint id, GLfloat[] parameters)
-
-        public static
-        void ExecuteProgramNV(GLenum target, GLuint id, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ExecuteProgramNV_(target, id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenProgramsNV(GLsizei n, IntPtr programs)
-
-        public static
-        void GenProgramsNV(GLsizei n, IntPtr programs)
-        {
-            GenProgramsNV_(n, programs);
-        }
-
-        #endregion
-
-        #region GenProgramsNV(GLsizei n, object programs)
-
-        public static
-        void GenProgramsNV(GLsizei n, object programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                GenProgramsNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenProgramsNV(GLsizei n, GLuint[] programs)
-
-        public static
-        void GenProgramsNV(GLsizei n, GLuint[] programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                GenProgramsNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetProgramParameterdvNV_(target, index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramParameterdvNV_(target, index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble[] parameters)
-
-        public static
-        void GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramParameterdvNV_(target, index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetProgramParameterfvNV_(target, index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramParameterfvNV_(target, index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramParameterfvNV_(target, index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramivNV(GLuint id, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetProgramivNV(GLuint id, GLenum pname, IntPtr parameters)
-        {
-            GetProgramivNV_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramivNV(GLuint id, GLenum pname, object parameters)
-
-        public static
-        void GetProgramivNV(GLuint id, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramivNV_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramivNV(GLuint id, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetProgramivNV(GLuint id, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramivNV_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramStringNV(GLuint id, GLenum pname, IntPtr program)
-
-        public static
-        void GetProgramStringNV(GLuint id, GLenum pname, IntPtr program)
-        {
-            GetProgramStringNV_(id, pname, program);
-        }
-
-        #endregion
-
-        #region GetProgramStringNV(GLuint id, GLenum pname, object program)
-
-        public static
-        void GetProgramStringNV(GLuint id, GLenum pname, object program)
-        {
-            GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
-            try
-            {
-                GetProgramStringNV_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramStringNV(GLuint id, GLenum pname, GLubyte[] program)
-
-        public static
-        void GetProgramStringNV(GLuint id, GLenum pname, GLubyte[] program)
-        {
-            GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
-            try
-            {
-                GetProgramStringNV_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, IntPtr parameters)
-        {
-            GetTrackMatrixivNV_(target, address, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, object parameters)
-
-        public static
-        void GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetTrackMatrixivNV_(target, address, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetTrackMatrixivNV_(target, address, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribdvNV(GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVertexAttribdvNV(GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetVertexAttribdvNV_(index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVertexAttribdvNV(GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetVertexAttribdvNV(GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribdvNV_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble[] parameters)
-
-        public static
-        void GetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribdvNV_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribfvNV(GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVertexAttribfvNV(GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetVertexAttribfvNV_(index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVertexAttribfvNV(GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetVertexAttribfvNV(GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribfvNV_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribfvNV_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribivNV(GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVertexAttribivNV(GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetVertexAttribivNV_(index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVertexAttribivNV(GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetVertexAttribivNV(GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribivNV_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribivNV(GLuint index, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetVertexAttribivNV(GLuint index, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribivNV_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribPointervNV(GLuint index, GLenum pname, IntPtr pointer)
-
-        public static
-        void GetVertexAttribPointervNV(GLuint index, GLenum pname, IntPtr pointer)
-        {
-            GetVertexAttribPointervNV_(index, pname, pointer);
-        }
-
-        #endregion
-
-        #region GetVertexAttribPointervNV(GLuint index, GLenum pname, object pointer)
-
-        public static
-        void GetVertexAttribPointervNV(GLuint index, GLenum pname, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribPointervNV_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribPointervNV(GLuint index, GLenum pname, IntPtr[] pointer)
-
-        public static
-        void GetVertexAttribPointervNV(GLuint index, GLenum pname, IntPtr[] pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribPointervNV_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region LoadProgramNV(GLenum target, GLuint id, GLsizei len, IntPtr program)
-
-        public static
-        void LoadProgramNV(GLenum target, GLuint id, GLsizei len, IntPtr program)
-        {
-            LoadProgramNV_(target, id, len, program);
-        }
-
-        #endregion
-
-        #region LoadProgramNV(GLenum target, GLuint id, GLsizei len, object program)
-
-        public static
-        void LoadProgramNV(GLenum target, GLuint id, GLsizei len, object program)
-        {
-            GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
-            try
-            {
-                LoadProgramNV_(target, id, len, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region LoadProgramNV(GLenum target, GLuint id, GLsizei len, GLubyte[] program)
-
-        public static
-        void LoadProgramNV(GLenum target, GLuint id, GLsizei len, GLubyte[] program)
-        {
-            GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
-            try
-            {
-                LoadProgramNV_(target, id, len, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramParameter4dvNV(GLenum target, GLuint index, IntPtr v)
-
-        public static
-        void ProgramParameter4dvNV(GLenum target, GLuint index, IntPtr v)
-        {
-            ProgramParameter4dvNV_(target, index, v);
-        }
-
-        #endregion
-
-        #region ProgramParameter4dvNV(GLenum target, GLuint index, object v)
-
-        public static
-        void ProgramParameter4dvNV(GLenum target, GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramParameter4dvNV_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramParameter4dvNV(GLenum target, GLuint index, GLdouble[] v)
-
-        public static
-        void ProgramParameter4dvNV(GLenum target, GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramParameter4dvNV_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramParameter4fvNV(GLenum target, GLuint index, IntPtr v)
-
-        public static
-        void ProgramParameter4fvNV(GLenum target, GLuint index, IntPtr v)
-        {
-            ProgramParameter4fvNV_(target, index, v);
-        }
-
-        #endregion
-
-        #region ProgramParameter4fvNV(GLenum target, GLuint index, object v)
-
-        public static
-        void ProgramParameter4fvNV(GLenum target, GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramParameter4fvNV_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramParameter4fvNV(GLenum target, GLuint index, GLfloat[] v)
-
-        public static
-        void ProgramParameter4fvNV(GLenum target, GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramParameter4fvNV_(target, index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, IntPtr v)
-
-        public static
-        void ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, IntPtr v)
-        {
-            ProgramParameters4dvNV_(target, index, count, v);
-        }
-
-        #endregion
-
-        #region ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, object v)
-
-        public static
-        void ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramParameters4dvNV_(target, index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, GLdouble[] v)
-
-        public static
-        void ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramParameters4dvNV_(target, index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, IntPtr v)
-
-        public static
-        void ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, IntPtr v)
-        {
-            ProgramParameters4fvNV_(target, index, count, v);
-        }
-
-        #endregion
-
-        #region ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, object v)
-
-        public static
-        void ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramParameters4fvNV_(target, index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, GLfloat[] v)
-
-        public static
-        void ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramParameters4fvNV_(target, index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region RequestResidentProgramsNV(GLsizei n, IntPtr programs)
-
-        public static
-        void RequestResidentProgramsNV(GLsizei n, IntPtr programs)
-        {
-            RequestResidentProgramsNV_(n, programs);
-        }
-
-        #endregion
-
-        #region RequestResidentProgramsNV(GLsizei n, object programs)
-
-        public static
-        void RequestResidentProgramsNV(GLsizei n, object programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                RequestResidentProgramsNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region RequestResidentProgramsNV(GLsizei n, GLuint[] programs)
-
-        public static
-        void RequestResidentProgramsNV(GLsizei n, GLuint[] programs)
-        {
-            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
-            try
-            {
-                RequestResidentProgramsNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, IntPtr pointer)
-
-        public static
-        void VertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, IntPtr pointer)
-        {
-            VertexAttribPointerNV_(index, fsize, type, stride, pointer);
-        }
-
-        #endregion
-
-        #region VertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, object pointer)
-
-        public static
-        void VertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribPointerNV_(index, fsize, type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1dvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib1dvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib1dvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib1dvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib1dvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1dvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1dvNV(GLuint index, GLdouble[] v)
-
-        public static
-        void VertexAttrib1dvNV(GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1dvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1fvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib1fvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib1fvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib1fvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib1fvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1fvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1fvNV(GLuint index, GLfloat[] v)
-
-        public static
-        void VertexAttrib1fvNV(GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1fvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1svNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib1svNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib1svNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib1svNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib1svNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1svNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1svNV(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib1svNV(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1svNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2dvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib2dvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib2dvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib2dvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib2dvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2dvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2dvNV(GLuint index, GLdouble[] v)
-
-        public static
-        void VertexAttrib2dvNV(GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2dvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2fvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib2fvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib2fvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib2fvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib2fvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2fvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2fvNV(GLuint index, GLfloat[] v)
-
-        public static
-        void VertexAttrib2fvNV(GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2fvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2svNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib2svNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib2svNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib2svNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib2svNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2svNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2svNV(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib2svNV(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2svNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3dvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib3dvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib3dvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib3dvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib3dvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3dvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3dvNV(GLuint index, GLdouble[] v)
-
-        public static
-        void VertexAttrib3dvNV(GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3dvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3fvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib3fvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib3fvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib3fvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib3fvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3fvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3fvNV(GLuint index, GLfloat[] v)
-
-        public static
-        void VertexAttrib3fvNV(GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3fvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3svNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib3svNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib3svNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib3svNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib3svNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3svNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3svNV(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib3svNV(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3svNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4dvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4dvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib4dvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4dvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib4dvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4dvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4dvNV(GLuint index, GLdouble[] v)
-
-        public static
-        void VertexAttrib4dvNV(GLuint index, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4dvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4fvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4fvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib4fvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4fvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib4fvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4fvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4fvNV(GLuint index, GLfloat[] v)
-
-        public static
-        void VertexAttrib4fvNV(GLuint index, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4fvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4svNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4svNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib4svNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4svNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib4svNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4svNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4svNV(GLuint index, GLshort[] v)
-
-        public static
-        void VertexAttrib4svNV(GLuint index, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4svNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4ubvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4ubvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib4ubvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4ubvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib4ubvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4ubvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4ubvNV(GLuint index, GLubyte[] v)
-
-        public static
-        void VertexAttrib4ubvNV(GLuint index, GLubyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4ubvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs1dvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs1dvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs1dvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs1dvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs1dvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs1dvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs1dvNV(GLuint index, GLsizei count, GLdouble[] v)
-
-        public static
-        void VertexAttribs1dvNV(GLuint index, GLsizei count, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs1dvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs1fvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs1fvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs1fvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs1fvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs1fvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs1fvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs1fvNV(GLuint index, GLsizei count, GLfloat[] v)
-
-        public static
-        void VertexAttribs1fvNV(GLuint index, GLsizei count, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs1fvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs1svNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs1svNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs1svNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs1svNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs1svNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs1svNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs1svNV(GLuint index, GLsizei count, GLshort[] v)
-
-        public static
-        void VertexAttribs1svNV(GLuint index, GLsizei count, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs1svNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs2dvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs2dvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs2dvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs2dvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs2dvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs2dvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs2dvNV(GLuint index, GLsizei count, GLdouble[] v)
-
-        public static
-        void VertexAttribs2dvNV(GLuint index, GLsizei count, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs2dvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs2fvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs2fvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs2fvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs2fvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs2fvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs2fvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs2fvNV(GLuint index, GLsizei count, GLfloat[] v)
-
-        public static
-        void VertexAttribs2fvNV(GLuint index, GLsizei count, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs2fvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs2svNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs2svNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs2svNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs2svNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs2svNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs2svNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs2svNV(GLuint index, GLsizei count, GLshort[] v)
-
-        public static
-        void VertexAttribs2svNV(GLuint index, GLsizei count, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs2svNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs3dvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs3dvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs3dvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs3dvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs3dvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs3dvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs3dvNV(GLuint index, GLsizei count, GLdouble[] v)
-
-        public static
-        void VertexAttribs3dvNV(GLuint index, GLsizei count, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs3dvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs3fvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs3fvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs3fvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs3fvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs3fvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs3fvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs3fvNV(GLuint index, GLsizei count, GLfloat[] v)
-
-        public static
-        void VertexAttribs3fvNV(GLuint index, GLsizei count, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs3fvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs3svNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs3svNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs3svNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs3svNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs3svNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs3svNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs3svNV(GLuint index, GLsizei count, GLshort[] v)
-
-        public static
-        void VertexAttribs3svNV(GLuint index, GLsizei count, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs3svNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4dvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs4dvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs4dvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs4dvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs4dvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4dvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4dvNV(GLuint index, GLsizei count, GLdouble[] v)
-
-        public static
-        void VertexAttribs4dvNV(GLuint index, GLsizei count, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4dvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4fvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs4fvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs4fvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs4fvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs4fvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4fvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4fvNV(GLuint index, GLsizei count, GLfloat[] v)
-
-        public static
-        void VertexAttribs4fvNV(GLuint index, GLsizei count, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4fvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4svNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs4svNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs4svNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs4svNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs4svNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4svNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4svNV(GLuint index, GLsizei count, GLshort[] v)
-
-        public static
-        void VertexAttribs4svNV(GLuint index, GLsizei count, GLshort[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4svNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4ubvNV(GLuint index, GLsizei count, IntPtr v)
-
-        public static
-        void VertexAttribs4ubvNV(GLuint index, GLsizei count, IntPtr v)
-        {
-            VertexAttribs4ubvNV_(index, count, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs4ubvNV(GLuint index, GLsizei count, object v)
-
-        public static
-        void VertexAttribs4ubvNV(GLuint index, GLsizei count, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4ubvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4ubvNV(GLuint index, GLsizei count, GLubyte[] v)
-
-        public static
-        void VertexAttribs4ubvNV(GLuint index, GLsizei count, GLubyte[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4ubvNV_(index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexBumpParameterivATI(GLenum pname, IntPtr param)
-
-        public static
-        void TexBumpParameterivATI(GLenum pname, IntPtr param)
-        {
-            TexBumpParameterivATI_(pname, param);
-        }
-
-        #endregion
-
-        #region TexBumpParameterivATI(GLenum pname, object param)
-
-        public static
-        void TexBumpParameterivATI(GLenum pname, object param)
-        {
-            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
-            try
-            {
-                TexBumpParameterivATI_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexBumpParameterivATI(GLenum pname, GLint[] param)
-
-        public static
-        void TexBumpParameterivATI(GLenum pname, GLint[] param)
-        {
-            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
-            try
-            {
-                TexBumpParameterivATI_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexBumpParameterfvATI(GLenum pname, IntPtr param)
-
-        public static
-        void TexBumpParameterfvATI(GLenum pname, IntPtr param)
-        {
-            TexBumpParameterfvATI_(pname, param);
-        }
-
-        #endregion
-
-        #region TexBumpParameterfvATI(GLenum pname, object param)
-
-        public static
-        void TexBumpParameterfvATI(GLenum pname, object param)
-        {
-            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
-            try
-            {
-                TexBumpParameterfvATI_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexBumpParameterfvATI(GLenum pname, GLfloat[] param)
-
-        public static
-        void TexBumpParameterfvATI(GLenum pname, GLfloat[] param)
-        {
-            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
-            try
-            {
-                TexBumpParameterfvATI_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetTexBumpParameterivATI(GLenum pname, IntPtr param)
-
-        public static
-        void GetTexBumpParameterivATI(GLenum pname, IntPtr param)
-        {
-            GetTexBumpParameterivATI_(pname, param);
-        }
-
-        #endregion
-
-        #region GetTexBumpParameterivATI(GLenum pname, object param)
-
-        public static
-        void GetTexBumpParameterivATI(GLenum pname, object param)
-        {
-            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
-            try
-            {
-                GetTexBumpParameterivATI_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetTexBumpParameterivATI(GLenum pname, GLint[] param)
-
-        public static
-        void GetTexBumpParameterivATI(GLenum pname, GLint[] param)
-        {
-            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
-            try
-            {
-                GetTexBumpParameterivATI_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetTexBumpParameterfvATI(GLenum pname, IntPtr param)
-
-        public static
-        void GetTexBumpParameterfvATI(GLenum pname, IntPtr param)
-        {
-            GetTexBumpParameterfvATI_(pname, param);
-        }
-
-        #endregion
-
-        #region GetTexBumpParameterfvATI(GLenum pname, object param)
-
-        public static
-        void GetTexBumpParameterfvATI(GLenum pname, object param)
-        {
-            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
-            try
-            {
-                GetTexBumpParameterfvATI_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetTexBumpParameterfvATI(GLenum pname, GLfloat[] param)
-
-        public static
-        void GetTexBumpParameterfvATI(GLenum pname, GLfloat[] param)
-        {
-            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
-            try
-            {
-                GetTexBumpParameterfvATI_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SetFragmentShaderConstantATI(GLuint dst, IntPtr value)
-
-        public static
-        void SetFragmentShaderConstantATI(GLuint dst, IntPtr value)
-        {
-            SetFragmentShaderConstantATI_(dst, value);
-        }
-
-        #endregion
-
-        #region SetFragmentShaderConstantATI(GLuint dst, object value)
-
-        public static
-        void SetFragmentShaderConstantATI(GLuint dst, object value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                SetFragmentShaderConstantATI_(dst, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SetFragmentShaderConstantATI(GLuint dst, GLfloat[] value)
-
-        public static
-        void SetFragmentShaderConstantATI(GLuint dst, GLfloat[] value)
-        {
-            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
-            try
-            {
-                SetFragmentShaderConstantATI_(dst, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NewObjectBufferATI(GLsizei size, IntPtr pointer, GLenum usage)
-
-        public static
-        GLuint NewObjectBufferATI(GLsizei size, IntPtr pointer, GLenum usage)
-        {
-            return NewObjectBufferATI_(size, pointer, usage);
-        }
-
-        #endregion
-
-        #region NewObjectBufferATI(GLsizei size, object pointer, GLenum usage)
-
-        public static
-        GLuint NewObjectBufferATI(GLsizei size, object pointer, GLenum usage)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                return NewObjectBufferATI_(size, h0.AddrOfPinnedObject(), usage);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, IntPtr pointer, GLenum preserve)
-
-        public static
-        void UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, IntPtr pointer, GLenum preserve)
-        {
-            UpdateObjectBufferATI_(buffer, offset, size, pointer, preserve);
-        }
-
-        #endregion
-
-        #region UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, object pointer, GLenum preserve)
-
-        public static
-        void UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, object pointer, GLenum preserve)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                UpdateObjectBufferATI_(buffer, offset, size, h0.AddrOfPinnedObject(), preserve);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetObjectBufferfvATI(GLuint buffer, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetObjectBufferfvATI(GLuint buffer, GLenum pname, IntPtr parameters)
-        {
-            GetObjectBufferfvATI_(buffer, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetObjectBufferfvATI(GLuint buffer, GLenum pname, object parameters)
-
-        public static
-        void GetObjectBufferfvATI(GLuint buffer, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetObjectBufferfvATI_(buffer, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetObjectBufferfvATI_(buffer, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetObjectBufferivATI(GLuint buffer, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetObjectBufferivATI(GLuint buffer, GLenum pname, IntPtr parameters)
-        {
-            GetObjectBufferivATI_(buffer, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetObjectBufferivATI(GLuint buffer, GLenum pname, object parameters)
-
-        public static
-        void GetObjectBufferivATI(GLuint buffer, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetObjectBufferivATI_(buffer, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetObjectBufferivATI(GLuint buffer, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetObjectBufferivATI(GLuint buffer, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetObjectBufferivATI_(buffer, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, IntPtr parameters)
-        {
-            GetArrayObjectfvATI_(array, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, object parameters)
-
-        public static
-        void GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetArrayObjectfvATI_(array, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetArrayObjectfvATI_(array, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, IntPtr parameters)
-        {
-            GetArrayObjectivATI_(array, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, object parameters)
-
-        public static
-        void GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetArrayObjectivATI_(array, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetArrayObjectivATI_(array, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantArrayObjectfvATI(GLuint id, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVariantArrayObjectfvATI(GLuint id, GLenum pname, IntPtr parameters)
-        {
-            GetVariantArrayObjectfvATI_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVariantArrayObjectfvATI(GLuint id, GLenum pname, object parameters)
-
-        public static
-        void GetVariantArrayObjectfvATI(GLuint id, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVariantArrayObjectfvATI_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVariantArrayObjectfvATI_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantArrayObjectivATI(GLuint id, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVariantArrayObjectivATI(GLuint id, GLenum pname, IntPtr parameters)
-        {
-            GetVariantArrayObjectivATI_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVariantArrayObjectivATI(GLuint id, GLenum pname, object parameters)
-
-        public static
-        void GetVariantArrayObjectivATI(GLuint id, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVariantArrayObjectivATI_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVariantArrayObjectivATI_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SetInvariantEXT(GLuint id, GLenum type, IntPtr addr)
-
-        public static
-        void SetInvariantEXT(GLuint id, GLenum type, IntPtr addr)
-        {
-            SetInvariantEXT_(id, type, addr);
-        }
-
-        #endregion
-
-        #region SetInvariantEXT(GLuint id, GLenum type, object addr)
-
-        public static
-        void SetInvariantEXT(GLuint id, GLenum type, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                SetInvariantEXT_(id, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SetLocalConstantEXT(GLuint id, GLenum type, IntPtr addr)
-
-        public static
-        void SetLocalConstantEXT(GLuint id, GLenum type, IntPtr addr)
-        {
-            SetLocalConstantEXT_(id, type, addr);
-        }
-
-        #endregion
-
-        #region SetLocalConstantEXT(GLuint id, GLenum type, object addr)
-
-        public static
-        void SetLocalConstantEXT(GLuint id, GLenum type, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                SetLocalConstantEXT_(id, type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantbvEXT(GLuint id, IntPtr addr)
-
-        public static
-        void VariantbvEXT(GLuint id, IntPtr addr)
-        {
-            VariantbvEXT_(id, addr);
-        }
-
-        #endregion
-
-        #region VariantbvEXT(GLuint id, object addr)
-
-        public static
-        void VariantbvEXT(GLuint id, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantbvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantbvEXT(GLuint id, GLbyte[] addr)
-
-        public static
-        void VariantbvEXT(GLuint id, GLbyte[] addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantbvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantsvEXT(GLuint id, IntPtr addr)
-
-        public static
-        void VariantsvEXT(GLuint id, IntPtr addr)
-        {
-            VariantsvEXT_(id, addr);
-        }
-
-        #endregion
-
-        #region VariantsvEXT(GLuint id, object addr)
-
-        public static
-        void VariantsvEXT(GLuint id, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantsvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantsvEXT(GLuint id, GLshort[] addr)
-
-        public static
-        void VariantsvEXT(GLuint id, GLshort[] addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantsvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantivEXT(GLuint id, IntPtr addr)
-
-        public static
-        void VariantivEXT(GLuint id, IntPtr addr)
-        {
-            VariantivEXT_(id, addr);
-        }
-
-        #endregion
-
-        #region VariantivEXT(GLuint id, object addr)
-
-        public static
-        void VariantivEXT(GLuint id, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantivEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantivEXT(GLuint id, GLint[] addr)
-
-        public static
-        void VariantivEXT(GLuint id, GLint[] addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantivEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantfvEXT(GLuint id, IntPtr addr)
-
-        public static
-        void VariantfvEXT(GLuint id, IntPtr addr)
-        {
-            VariantfvEXT_(id, addr);
-        }
-
-        #endregion
-
-        #region VariantfvEXT(GLuint id, object addr)
-
-        public static
-        void VariantfvEXT(GLuint id, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantfvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantfvEXT(GLuint id, GLfloat[] addr)
-
-        public static
-        void VariantfvEXT(GLuint id, GLfloat[] addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantfvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantdvEXT(GLuint id, IntPtr addr)
-
-        public static
-        void VariantdvEXT(GLuint id, IntPtr addr)
-        {
-            VariantdvEXT_(id, addr);
-        }
-
-        #endregion
-
-        #region VariantdvEXT(GLuint id, object addr)
-
-        public static
-        void VariantdvEXT(GLuint id, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantdvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantdvEXT(GLuint id, GLdouble[] addr)
-
-        public static
-        void VariantdvEXT(GLuint id, GLdouble[] addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantdvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantubvEXT(GLuint id, IntPtr addr)
-
-        public static
-        void VariantubvEXT(GLuint id, IntPtr addr)
-        {
-            VariantubvEXT_(id, addr);
-        }
-
-        #endregion
-
-        #region VariantubvEXT(GLuint id, object addr)
-
-        public static
-        void VariantubvEXT(GLuint id, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantubvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantubvEXT(GLuint id, GLubyte[] addr)
-
-        public static
-        void VariantubvEXT(GLuint id, GLubyte[] addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantubvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantusvEXT(GLuint id, IntPtr addr)
-
-        public static
-        void VariantusvEXT(GLuint id, IntPtr addr)
-        {
-            VariantusvEXT_(id, addr);
-        }
-
-        #endregion
-
-        #region VariantusvEXT(GLuint id, object addr)
-
-        public static
-        void VariantusvEXT(GLuint id, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantusvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantusvEXT(GLuint id, GLushort[] addr)
-
-        public static
-        void VariantusvEXT(GLuint id, GLushort[] addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantusvEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantuivEXT(GLuint id, IntPtr addr)
-
-        public static
-        void VariantuivEXT(GLuint id, IntPtr addr)
-        {
-            VariantuivEXT_(id, addr);
-        }
-
-        #endregion
-
-        #region VariantuivEXT(GLuint id, object addr)
-
-        public static
-        void VariantuivEXT(GLuint id, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantuivEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantuivEXT(GLuint id, GLuint[] addr)
-
-        public static
-        void VariantuivEXT(GLuint id, GLuint[] addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantuivEXT_(id, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VariantPointerEXT(GLuint id, GLenum type, GLuint stride, IntPtr addr)
-
-        public static
-        void VariantPointerEXT(GLuint id, GLenum type, GLuint stride, IntPtr addr)
-        {
-            VariantPointerEXT_(id, type, stride, addr);
-        }
-
-        #endregion
-
-        #region VariantPointerEXT(GLuint id, GLenum type, GLuint stride, object addr)
-
-        public static
-        void VariantPointerEXT(GLuint id, GLenum type, GLuint stride, object addr)
-        {
-            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
-            try
-            {
-                VariantPointerEXT_(id, type, stride, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetVariantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetVariantBooleanvEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetVariantBooleanvEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetVariantBooleanvEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetVariantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantBooleanvEXT(GLuint id, GLenum value, GLboolean[] data)
-
-        public static
-        void GetVariantBooleanvEXT(GLuint id, GLenum value, GLboolean[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetVariantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantIntegervEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetVariantIntegervEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetVariantIntegervEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetVariantIntegervEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetVariantIntegervEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetVariantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantIntegervEXT(GLuint id, GLenum value, GLint[] data)
-
-        public static
-        void GetVariantIntegervEXT(GLuint id, GLenum value, GLint[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetVariantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantFloatvEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetVariantFloatvEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetVariantFloatvEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetVariantFloatvEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetVariantFloatvEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetVariantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
-
-        public static
-        void GetVariantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetVariantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantPointervEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetVariantPointervEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetVariantPointervEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetVariantPointervEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetVariantPointervEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetVariantPointervEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVariantPointervEXT(GLuint id, GLenum value, IntPtr[] data)
-
-        public static
-        void GetVariantPointervEXT(GLuint id, GLenum value, IntPtr[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetVariantPointervEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetInvariantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetInvariantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetInvariantBooleanvEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetInvariantBooleanvEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetInvariantBooleanvEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetInvariantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetInvariantBooleanvEXT(GLuint id, GLenum value, GLboolean[] data)
-
-        public static
-        void GetInvariantBooleanvEXT(GLuint id, GLenum value, GLboolean[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetInvariantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetInvariantIntegervEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetInvariantIntegervEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetInvariantIntegervEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetInvariantIntegervEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetInvariantIntegervEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetInvariantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetInvariantIntegervEXT(GLuint id, GLenum value, GLint[] data)
-
-        public static
-        void GetInvariantIntegervEXT(GLuint id, GLenum value, GLint[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetInvariantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetInvariantFloatvEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetInvariantFloatvEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetInvariantFloatvEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetInvariantFloatvEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetInvariantFloatvEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetInvariantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
-
-        public static
-        void GetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetInvariantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetLocalConstantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetLocalConstantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetLocalConstantBooleanvEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetLocalConstantBooleanvEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetLocalConstantBooleanvEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetLocalConstantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetLocalConstantBooleanvEXT(GLuint id, GLenum value, GLboolean[] data)
-
-        public static
-        void GetLocalConstantBooleanvEXT(GLuint id, GLenum value, GLboolean[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetLocalConstantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetLocalConstantIntegervEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetLocalConstantIntegervEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetLocalConstantIntegervEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetLocalConstantIntegervEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetLocalConstantIntegervEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetLocalConstantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint[] data)
-
-        public static
-        void GetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetLocalConstantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetLocalConstantFloatvEXT(GLuint id, GLenum value, IntPtr data)
-
-        public static
-        void GetLocalConstantFloatvEXT(GLuint id, GLenum value, IntPtr data)
-        {
-            GetLocalConstantFloatvEXT_(id, value, data);
-        }
-
-        #endregion
-
-        #region GetLocalConstantFloatvEXT(GLuint id, GLenum value, object data)
-
-        public static
-        void GetLocalConstantFloatvEXT(GLuint id, GLenum value, object data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetLocalConstantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
-
-        public static
-        void GetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
-        {
-            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
-            try
-            {
-                GetLocalConstantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream1svATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream1svATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream1svATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream1svATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream1svATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream1svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream1svATI(GLenum stream, GLshort[] coords)
-
-        public static
-        void VertexStream1svATI(GLenum stream, GLshort[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream1svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream1ivATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream1ivATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream1ivATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream1ivATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream1ivATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream1ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream1ivATI(GLenum stream, GLint[] coords)
-
-        public static
-        void VertexStream1ivATI(GLenum stream, GLint[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream1ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream1fvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream1fvATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream1fvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream1fvATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream1fvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream1fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream1fvATI(GLenum stream, GLfloat[] coords)
-
-        public static
-        void VertexStream1fvATI(GLenum stream, GLfloat[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream1fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream1dvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream1dvATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream1dvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream1dvATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream1dvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream1dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream1dvATI(GLenum stream, GLdouble[] coords)
-
-        public static
-        void VertexStream1dvATI(GLenum stream, GLdouble[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream1dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream2svATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream2svATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream2svATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream2svATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream2svATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream2svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream2svATI(GLenum stream, GLshort[] coords)
-
-        public static
-        void VertexStream2svATI(GLenum stream, GLshort[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream2svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream2ivATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream2ivATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream2ivATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream2ivATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream2ivATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream2ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream2ivATI(GLenum stream, GLint[] coords)
-
-        public static
-        void VertexStream2ivATI(GLenum stream, GLint[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream2ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream2fvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream2fvATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream2fvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream2fvATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream2fvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream2fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream2fvATI(GLenum stream, GLfloat[] coords)
-
-        public static
-        void VertexStream2fvATI(GLenum stream, GLfloat[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream2fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream2dvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream2dvATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream2dvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream2dvATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream2dvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream2dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream2dvATI(GLenum stream, GLdouble[] coords)
-
-        public static
-        void VertexStream2dvATI(GLenum stream, GLdouble[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream2dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream3svATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream3svATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream3svATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream3svATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream3svATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream3svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream3svATI(GLenum stream, GLshort[] coords)
-
-        public static
-        void VertexStream3svATI(GLenum stream, GLshort[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream3svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream3ivATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream3ivATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream3ivATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream3ivATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream3ivATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream3ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream3ivATI(GLenum stream, GLint[] coords)
-
-        public static
-        void VertexStream3ivATI(GLenum stream, GLint[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream3ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream3fvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream3fvATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream3fvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream3fvATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream3fvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream3fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream3fvATI(GLenum stream, GLfloat[] coords)
-
-        public static
-        void VertexStream3fvATI(GLenum stream, GLfloat[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream3fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream3dvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream3dvATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream3dvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream3dvATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream3dvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream3dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream3dvATI(GLenum stream, GLdouble[] coords)
-
-        public static
-        void VertexStream3dvATI(GLenum stream, GLdouble[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream3dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream4svATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream4svATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream4svATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream4svATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream4svATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream4svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream4svATI(GLenum stream, GLshort[] coords)
-
-        public static
-        void VertexStream4svATI(GLenum stream, GLshort[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream4svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream4ivATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream4ivATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream4ivATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream4ivATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream4ivATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream4ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream4ivATI(GLenum stream, GLint[] coords)
-
-        public static
-        void VertexStream4ivATI(GLenum stream, GLint[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream4ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream4fvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream4fvATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream4fvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream4fvATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream4fvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream4fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream4fvATI(GLenum stream, GLfloat[] coords)
-
-        public static
-        void VertexStream4fvATI(GLenum stream, GLfloat[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream4fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream4dvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void VertexStream4dvATI(GLenum stream, IntPtr coords)
-        {
-            VertexStream4dvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region VertexStream4dvATI(GLenum stream, object coords)
-
-        public static
-        void VertexStream4dvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream4dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexStream4dvATI(GLenum stream, GLdouble[] coords)
-
-        public static
-        void VertexStream4dvATI(GLenum stream, GLdouble[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                VertexStream4dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3bvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void NormalStream3bvATI(GLenum stream, IntPtr coords)
-        {
-            NormalStream3bvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region NormalStream3bvATI(GLenum stream, object coords)
-
-        public static
-        void NormalStream3bvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3bvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3bvATI(GLenum stream, GLbyte[] coords)
-
-        public static
-        void NormalStream3bvATI(GLenum stream, GLbyte[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3bvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3svATI(GLenum stream, IntPtr coords)
-
-        public static
-        void NormalStream3svATI(GLenum stream, IntPtr coords)
-        {
-            NormalStream3svATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region NormalStream3svATI(GLenum stream, object coords)
-
-        public static
-        void NormalStream3svATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3svATI(GLenum stream, GLshort[] coords)
-
-        public static
-        void NormalStream3svATI(GLenum stream, GLshort[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3svATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3ivATI(GLenum stream, IntPtr coords)
-
-        public static
-        void NormalStream3ivATI(GLenum stream, IntPtr coords)
-        {
-            NormalStream3ivATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region NormalStream3ivATI(GLenum stream, object coords)
-
-        public static
-        void NormalStream3ivATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3ivATI(GLenum stream, GLint[] coords)
-
-        public static
-        void NormalStream3ivATI(GLenum stream, GLint[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3ivATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3fvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void NormalStream3fvATI(GLenum stream, IntPtr coords)
-        {
-            NormalStream3fvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region NormalStream3fvATI(GLenum stream, object coords)
-
-        public static
-        void NormalStream3fvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3fvATI(GLenum stream, GLfloat[] coords)
-
-        public static
-        void NormalStream3fvATI(GLenum stream, GLfloat[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3fvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3dvATI(GLenum stream, IntPtr coords)
-
-        public static
-        void NormalStream3dvATI(GLenum stream, IntPtr coords)
-        {
-            NormalStream3dvATI_(stream, coords);
-        }
-
-        #endregion
-
-        #region NormalStream3dvATI(GLenum stream, object coords)
-
-        public static
-        void NormalStream3dvATI(GLenum stream, object coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region NormalStream3dvATI(GLenum stream, GLdouble[] coords)
-
-        public static
-        void NormalStream3dvATI(GLenum stream, GLdouble[] coords)
-        {
-            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
-            try
-            {
-                NormalStream3dvATI_(stream, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ElementPointerATI(GLenum type, IntPtr pointer)
-
-        public static
-        void ElementPointerATI(GLenum type, IntPtr pointer)
-        {
-            ElementPointerATI_(type, pointer);
-        }
-
-        #endregion
-
-        #region ElementPointerATI(GLenum type, object pointer)
-
-        public static
-        void ElementPointerATI(GLenum type, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ElementPointerATI_(type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenOcclusionQueriesNV(GLsizei n, IntPtr ids)
-
-        public static
-        void GenOcclusionQueriesNV(GLsizei n, IntPtr ids)
-        {
-            GenOcclusionQueriesNV_(n, ids);
-        }
-
-        #endregion
-
-        #region GenOcclusionQueriesNV(GLsizei n, object ids)
-
-        public static
-        void GenOcclusionQueriesNV(GLsizei n, object ids)
-        {
-            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
-            try
-            {
-                GenOcclusionQueriesNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenOcclusionQueriesNV(GLsizei n, GLuint[] ids)
-
-        public static
-        void GenOcclusionQueriesNV(GLsizei n, GLuint[] ids)
-        {
-            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
-            try
-            {
-                GenOcclusionQueriesNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteOcclusionQueriesNV(GLsizei n, IntPtr ids)
-
-        public static
-        void DeleteOcclusionQueriesNV(GLsizei n, IntPtr ids)
-        {
-            DeleteOcclusionQueriesNV_(n, ids);
-        }
-
-        #endregion
-
-        #region DeleteOcclusionQueriesNV(GLsizei n, object ids)
-
-        public static
-        void DeleteOcclusionQueriesNV(GLsizei n, object ids)
-        {
-            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
-            try
-            {
-                DeleteOcclusionQueriesNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteOcclusionQueriesNV(GLsizei n, GLuint[] ids)
-
-        public static
-        void DeleteOcclusionQueriesNV(GLsizei n, GLuint[] ids)
-        {
-            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
-            try
-            {
-                DeleteOcclusionQueriesNV_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetOcclusionQueryivNV(GLuint id, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetOcclusionQueryivNV(GLuint id, GLenum pname, IntPtr parameters)
-        {
-            GetOcclusionQueryivNV_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetOcclusionQueryivNV(GLuint id, GLenum pname, object parameters)
-
-        public static
-        void GetOcclusionQueryivNV(GLuint id, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetOcclusionQueryivNV_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetOcclusionQueryivNV(GLuint id, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetOcclusionQueryivNV(GLuint id, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetOcclusionQueryivNV_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetOcclusionQueryuivNV(GLuint id, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetOcclusionQueryuivNV(GLuint id, GLenum pname, IntPtr parameters)
-        {
-            GetOcclusionQueryuivNV_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetOcclusionQueryuivNV(GLuint id, GLenum pname, object parameters)
-
-        public static
-        void GetOcclusionQueryuivNV(GLuint id, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetOcclusionQueryuivNV_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint[] parameters)
-
-        public static
-        void GetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetOcclusionQueryuivNV_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PointParameterivNV(GLenum pname, IntPtr parameters)
-
-        public static
-        void PointParameterivNV(GLenum pname, IntPtr parameters)
-        {
-            PointParameterivNV_(pname, parameters);
-        }
-
-        #endregion
-
-        #region PointParameterivNV(GLenum pname, object parameters)
-
-        public static
-        void PointParameterivNV(GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PointParameterivNV_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PointParameterivNV(GLenum pname, GLint[] parameters)
-
-        public static
-        void PointParameterivNV(GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                PointParameterivNV_(pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ElementPointerAPPLE(GLenum type, IntPtr pointer)
-
-        public static
-        void ElementPointerAPPLE(GLenum type, IntPtr pointer)
-        {
-            ElementPointerAPPLE_(type, pointer);
-        }
-
-        #endregion
-
-        #region ElementPointerAPPLE(GLenum type, object pointer)
-
-        public static
-        void ElementPointerAPPLE(GLenum type, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                ElementPointerAPPLE_(type, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount)
-        {
-            MultiDrawElementArrayAPPLE_(mode, first, count, primcount);
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementArrayAPPLE_(mode, first, h0.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementArrayAPPLE_(mode, first, h0.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, IntPtr count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), count, primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, IntPtr count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), count, primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, IntPtr count, GLsizei primcount)
-        {
-            MultiDrawRangeElementArrayAPPLE_(mode, start, end, first, count, primcount);
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawRangeElementArrayAPPLE_(mode, start, end, first, h0.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawRangeElementArrayAPPLE_(mode, start, end, first, h0.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, IntPtr count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), count, primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, IntPtr count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, IntPtr count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), count, primcount);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, object count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, object count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei[] count, GLsizei primcount)
-
-        public static
-        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei[] count, GLsizei primcount)
-        {
-            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
-            try
-            {
-                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenFencesAPPLE(GLsizei n, IntPtr fences)
-
-        public static
-        void GenFencesAPPLE(GLsizei n, IntPtr fences)
-        {
-            GenFencesAPPLE_(n, fences);
-        }
-
-        #endregion
-
-        #region GenFencesAPPLE(GLsizei n, object fences)
-
-        public static
-        void GenFencesAPPLE(GLsizei n, object fences)
-        {
-            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
-            try
-            {
-                GenFencesAPPLE_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenFencesAPPLE(GLsizei n, GLuint[] fences)
-
-        public static
-        void GenFencesAPPLE(GLsizei n, GLuint[] fences)
-        {
-            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
-            try
-            {
-                GenFencesAPPLE_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteFencesAPPLE(GLsizei n, IntPtr fences)
-
-        public static
-        void DeleteFencesAPPLE(GLsizei n, IntPtr fences)
-        {
-            DeleteFencesAPPLE_(n, fences);
-        }
-
-        #endregion
-
-        #region DeleteFencesAPPLE(GLsizei n, object fences)
-
-        public static
-        void DeleteFencesAPPLE(GLsizei n, object fences)
-        {
-            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
-            try
-            {
-                DeleteFencesAPPLE_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteFencesAPPLE(GLsizei n, GLuint[] fences)
-
-        public static
-        void DeleteFencesAPPLE(GLsizei n, GLuint[] fences)
-        {
-            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
-            try
-            {
-                DeleteFencesAPPLE_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteVertexArraysAPPLE(GLsizei n, IntPtr arrays)
-
-        public static
-        void DeleteVertexArraysAPPLE(GLsizei n, IntPtr arrays)
-        {
-            DeleteVertexArraysAPPLE_(n, arrays);
-        }
-
-        #endregion
-
-        #region DeleteVertexArraysAPPLE(GLsizei n, object arrays)
-
-        public static
-        void DeleteVertexArraysAPPLE(GLsizei n, object arrays)
-        {
-            GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
-            try
-            {
-                DeleteVertexArraysAPPLE_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
-
-        public static
-        void DeleteVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
-        {
-            GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
-            try
-            {
-                DeleteVertexArraysAPPLE_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenVertexArraysAPPLE(GLsizei n, IntPtr arrays)
-
-        public static
-        void GenVertexArraysAPPLE(GLsizei n, IntPtr arrays)
-        {
-            GenVertexArraysAPPLE_(n, arrays);
-        }
-
-        #endregion
-
-        #region GenVertexArraysAPPLE(GLsizei n, object arrays)
-
-        public static
-        void GenVertexArraysAPPLE(GLsizei n, object arrays)
-        {
-            GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
-            try
-            {
-                GenVertexArraysAPPLE_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
-
-        public static
-        void GenVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
-        {
-            GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
-            try
-            {
-                GenVertexArraysAPPLE_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexArrayRangeAPPLE(GLsizei length, IntPtr pointer)
-
-        public static
-        void VertexArrayRangeAPPLE(GLsizei length, IntPtr pointer)
-        {
-            VertexArrayRangeAPPLE_(length, pointer);
-        }
-
-        #endregion
-
-        #region VertexArrayRangeAPPLE(GLsizei length, object pointer)
-
-        public static
-        void VertexArrayRangeAPPLE(GLsizei length, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                VertexArrayRangeAPPLE_(length, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FlushVertexArrayRangeAPPLE(GLsizei length, IntPtr pointer)
-
-        public static
-        void FlushVertexArrayRangeAPPLE(GLsizei length, IntPtr pointer)
-        {
-            FlushVertexArrayRangeAPPLE_(length, pointer);
-        }
-
-        #endregion
-
-        #region FlushVertexArrayRangeAPPLE(GLsizei length, object pointer)
-
-        public static
-        void FlushVertexArrayRangeAPPLE(GLsizei length, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                FlushVertexArrayRangeAPPLE_(length, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DrawBuffersATI(GLsizei n, IntPtr bufs)
-
-        public static
-        void DrawBuffersATI(GLsizei n, IntPtr bufs)
-        {
-            DrawBuffersATI_(n, bufs);
-        }
-
-        #endregion
-
-        #region DrawBuffersATI(GLsizei n, object bufs)
-
-        public static
-        void DrawBuffersATI(GLsizei n, object bufs)
-        {
-            GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
-            try
-            {
-                DrawBuffersATI_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DrawBuffersATI(GLsizei n, GLenum[] bufs)
-
-        public static
-        void DrawBuffersATI(GLsizei n, GLenum[] bufs)
-        {
-            GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
-            try
-            {
-                DrawBuffersATI_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fNV(GLuint id, GLsizei len, IntPtr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-
-        public static
-        void ProgramNamedParameter4fNV(GLuint id, GLsizei len, IntPtr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-        {
-            ProgramNamedParameter4fNV_(id, len, name, x, y, z, w);
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fNV(GLuint id, GLsizei len, object name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-
-        public static
-        void ProgramNamedParameter4fNV(GLuint id, GLsizei len, object name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fNV_(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-
-        public static
-        void ProgramNamedParameter4fNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fNV_(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dNV(GLuint id, GLsizei len, IntPtr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-
-        public static
-        void ProgramNamedParameter4dNV(GLuint id, GLsizei len, IntPtr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-        {
-            ProgramNamedParameter4dNV_(id, len, name, x, y, z, w);
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dNV(GLuint id, GLsizei len, object name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-
-        public static
-        void ProgramNamedParameter4dNV(GLuint id, GLsizei len, object name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dNV_(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-
-        public static
-        void ProgramNamedParameter4dNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dNV_(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, IntPtr v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, IntPtr v)
-        {
-            ProgramNamedParameter4fvNV_(id, len, name, v);
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, object v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fvNV_(id, len, name, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, GLfloat[] v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fvNV_(id, len, name, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, IntPtr v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, object v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, GLfloat[] v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, object v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] v)
-
-        public static
-        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, IntPtr v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, IntPtr v)
-        {
-            ProgramNamedParameter4dvNV_(id, len, name, v);
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, object v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dvNV_(id, len, name, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, GLdouble[] v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dvNV_(id, len, name, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, IntPtr v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, object v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, GLdouble[] v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), v);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, object v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] v)
-
-        public static
-        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, IntPtr parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, IntPtr parameters)
-        {
-            GetProgramNamedParameterfvNV_(id, len, name, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, object parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterfvNV_(id, len, name, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, GLfloat[] parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterfvNV_(id, len, name, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, IntPtr parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, IntPtr parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), parameters);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, object parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, GLfloat[] parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), parameters);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, object parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] parameters)
-
-        public static
-        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, IntPtr parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, IntPtr parameters)
-        {
-            GetProgramNamedParameterdvNV_(id, len, name, parameters);
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, object parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterdvNV_(id, len, name, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, GLdouble[] parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterdvNV_(id, len, name, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, IntPtr parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, IntPtr parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), parameters);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, object parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, GLdouble[] parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), parameters);
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, object parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] parameters)
-
-        public static
-        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
-            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h1.Free();
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Vertex2hvNV(IntPtr v)
-
-        public static
-        void Vertex2hvNV(IntPtr v)
-        {
-            Vertex2hvNV_(v);
-        }
-
-        #endregion
-
-        #region Vertex2hvNV(object v)
-
-        public static
-        void Vertex2hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Vertex2hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Vertex2hvNV(GLhalfNV[] v)
-
-        public static
-        void Vertex2hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Vertex2hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Vertex3hvNV(IntPtr v)
-
-        public static
-        void Vertex3hvNV(IntPtr v)
-        {
-            Vertex3hvNV_(v);
-        }
-
-        #endregion
-
-        #region Vertex3hvNV(object v)
-
-        public static
-        void Vertex3hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Vertex3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Vertex3hvNV(GLhalfNV[] v)
-
-        public static
-        void Vertex3hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Vertex3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Vertex4hvNV(IntPtr v)
-
-        public static
-        void Vertex4hvNV(IntPtr v)
-        {
-            Vertex4hvNV_(v);
-        }
-
-        #endregion
-
-        #region Vertex4hvNV(object v)
-
-        public static
-        void Vertex4hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Vertex4hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Vertex4hvNV(GLhalfNV[] v)
-
-        public static
-        void Vertex4hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Vertex4hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3hvNV(IntPtr v)
-
-        public static
-        void Normal3hvNV(IntPtr v)
-        {
-            Normal3hvNV_(v);
-        }
-
-        #endregion
-
-        #region Normal3hvNV(object v)
-
-        public static
-        void Normal3hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Normal3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Normal3hvNV(GLhalfNV[] v)
-
-        public static
-        void Normal3hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Normal3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3hvNV(IntPtr v)
-
-        public static
-        void Color3hvNV(IntPtr v)
-        {
-            Color3hvNV_(v);
-        }
-
-        #endregion
-
-        #region Color3hvNV(object v)
-
-        public static
-        void Color3hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color3hvNV(GLhalfNV[] v)
-
-        public static
-        void Color3hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4hvNV(IntPtr v)
-
-        public static
-        void Color4hvNV(IntPtr v)
-        {
-            Color4hvNV_(v);
-        }
-
-        #endregion
-
-        #region Color4hvNV(object v)
-
-        public static
-        void Color4hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region Color4hvNV(GLhalfNV[] v)
-
-        public static
-        void Color4hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                Color4hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord1hvNV(IntPtr v)
-
-        public static
-        void TexCoord1hvNV(IntPtr v)
-        {
-            TexCoord1hvNV_(v);
-        }
-
-        #endregion
-
-        #region TexCoord1hvNV(object v)
-
-        public static
-        void TexCoord1hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord1hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord1hvNV(GLhalfNV[] v)
-
-        public static
-        void TexCoord1hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord1hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2hvNV(IntPtr v)
-
-        public static
-        void TexCoord2hvNV(IntPtr v)
-        {
-            TexCoord2hvNV_(v);
-        }
-
-        #endregion
-
-        #region TexCoord2hvNV(object v)
-
-        public static
-        void TexCoord2hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord2hvNV(GLhalfNV[] v)
-
-        public static
-        void TexCoord2hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord2hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord3hvNV(IntPtr v)
-
-        public static
-        void TexCoord3hvNV(IntPtr v)
-        {
-            TexCoord3hvNV_(v);
-        }
-
-        #endregion
-
-        #region TexCoord3hvNV(object v)
-
-        public static
-        void TexCoord3hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord3hvNV(GLhalfNV[] v)
-
-        public static
-        void TexCoord3hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4hvNV(IntPtr v)
-
-        public static
-        void TexCoord4hvNV(IntPtr v)
-        {
-            TexCoord4hvNV_(v);
-        }
-
-        #endregion
-
-        #region TexCoord4hvNV(object v)
-
-        public static
-        void TexCoord4hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region TexCoord4hvNV(GLhalfNV[] v)
-
-        public static
-        void TexCoord4hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                TexCoord4hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1hvNV(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord1hvNV(GLenum target, IntPtr v)
-        {
-            MultiTexCoord1hvNV_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord1hvNV(GLenum target, object v)
-
-        public static
-        void MultiTexCoord1hvNV(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1hvNV_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord1hvNV(GLenum target, GLhalfNV[] v)
-
-        public static
-        void MultiTexCoord1hvNV(GLenum target, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord1hvNV_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2hvNV(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord2hvNV(GLenum target, IntPtr v)
-        {
-            MultiTexCoord2hvNV_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord2hvNV(GLenum target, object v)
-
-        public static
-        void MultiTexCoord2hvNV(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2hvNV_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord2hvNV(GLenum target, GLhalfNV[] v)
-
-        public static
-        void MultiTexCoord2hvNV(GLenum target, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord2hvNV_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3hvNV(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord3hvNV(GLenum target, IntPtr v)
-        {
-            MultiTexCoord3hvNV_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord3hvNV(GLenum target, object v)
-
-        public static
-        void MultiTexCoord3hvNV(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3hvNV_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord3hvNV(GLenum target, GLhalfNV[] v)
-
-        public static
-        void MultiTexCoord3hvNV(GLenum target, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord3hvNV_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4hvNV(GLenum target, IntPtr v)
-
-        public static
-        void MultiTexCoord4hvNV(GLenum target, IntPtr v)
-        {
-            MultiTexCoord4hvNV_(target, v);
-        }
-
-        #endregion
-
-        #region MultiTexCoord4hvNV(GLenum target, object v)
-
-        public static
-        void MultiTexCoord4hvNV(GLenum target, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4hvNV_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region MultiTexCoord4hvNV(GLenum target, GLhalfNV[] v)
-
-        public static
-        void MultiTexCoord4hvNV(GLenum target, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                MultiTexCoord4hvNV_(target, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoordhvNV(IntPtr fog)
-
-        public static
-        void FogCoordhvNV(IntPtr fog)
-        {
-            FogCoordhvNV_(fog);
-        }
-
-        #endregion
-
-        #region FogCoordhvNV(object fog)
-
-        public static
-        void FogCoordhvNV(object fog)
-        {
-            GCHandle h0 = GCHandle.Alloc(fog, GCHandleType.Pinned);
-            try
-            {
-                FogCoordhvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region FogCoordhvNV(GLhalfNV[] fog)
-
-        public static
-        void FogCoordhvNV(GLhalfNV[] fog)
-        {
-            GCHandle h0 = GCHandle.Alloc(fog, GCHandleType.Pinned);
-            try
-            {
-                FogCoordhvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3hvNV(IntPtr v)
-
-        public static
-        void SecondaryColor3hvNV(IntPtr v)
-        {
-            SecondaryColor3hvNV_(v);
-        }
-
-        #endregion
-
-        #region SecondaryColor3hvNV(object v)
-
-        public static
-        void SecondaryColor3hvNV(object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region SecondaryColor3hvNV(GLhalfNV[] v)
-
-        public static
-        void SecondaryColor3hvNV(GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                SecondaryColor3hvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexWeighthvNV(IntPtr weight)
-
-        public static
-        void VertexWeighthvNV(IntPtr weight)
-        {
-            VertexWeighthvNV_(weight);
-        }
-
-        #endregion
-
-        #region VertexWeighthvNV(object weight)
-
-        public static
-        void VertexWeighthvNV(object weight)
-        {
-            GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
-            try
-            {
-                VertexWeighthvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexWeighthvNV(GLhalfNV[] weight)
-
-        public static
-        void VertexWeighthvNV(GLhalfNV[] weight)
-        {
-            GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
-            try
-            {
-                VertexWeighthvNV_(h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1hvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib1hvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib1hvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib1hvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib1hvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1hvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib1hvNV(GLuint index, GLhalfNV[] v)
-
-        public static
-        void VertexAttrib1hvNV(GLuint index, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib1hvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2hvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib2hvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib2hvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib2hvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib2hvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2hvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib2hvNV(GLuint index, GLhalfNV[] v)
-
-        public static
-        void VertexAttrib2hvNV(GLuint index, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib2hvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3hvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib3hvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib3hvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib3hvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib3hvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3hvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib3hvNV(GLuint index, GLhalfNV[] v)
-
-        public static
-        void VertexAttrib3hvNV(GLuint index, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib3hvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4hvNV(GLuint index, IntPtr v)
-
-        public static
-        void VertexAttrib4hvNV(GLuint index, IntPtr v)
-        {
-            VertexAttrib4hvNV_(index, v);
-        }
-
-        #endregion
-
-        #region VertexAttrib4hvNV(GLuint index, object v)
-
-        public static
-        void VertexAttrib4hvNV(GLuint index, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4hvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttrib4hvNV(GLuint index, GLhalfNV[] v)
-
-        public static
-        void VertexAttrib4hvNV(GLuint index, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttrib4hvNV_(index, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs1hvNV(GLuint index, GLsizei n, IntPtr v)
-
-        public static
-        void VertexAttribs1hvNV(GLuint index, GLsizei n, IntPtr v)
-        {
-            VertexAttribs1hvNV_(index, n, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs1hvNV(GLuint index, GLsizei n, object v)
-
-        public static
-        void VertexAttribs1hvNV(GLuint index, GLsizei n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs1hvNV_(index, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs1hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
-
-        public static
-        void VertexAttribs1hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs1hvNV_(index, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs2hvNV(GLuint index, GLsizei n, IntPtr v)
-
-        public static
-        void VertexAttribs2hvNV(GLuint index, GLsizei n, IntPtr v)
-        {
-            VertexAttribs2hvNV_(index, n, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs2hvNV(GLuint index, GLsizei n, object v)
-
-        public static
-        void VertexAttribs2hvNV(GLuint index, GLsizei n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs2hvNV_(index, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs2hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
-
-        public static
-        void VertexAttribs2hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs2hvNV_(index, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs3hvNV(GLuint index, GLsizei n, IntPtr v)
-
-        public static
-        void VertexAttribs3hvNV(GLuint index, GLsizei n, IntPtr v)
-        {
-            VertexAttribs3hvNV_(index, n, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs3hvNV(GLuint index, GLsizei n, object v)
-
-        public static
-        void VertexAttribs3hvNV(GLuint index, GLsizei n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs3hvNV_(index, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs3hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
-
-        public static
-        void VertexAttribs3hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs3hvNV_(index, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4hvNV(GLuint index, GLsizei n, IntPtr v)
-
-        public static
-        void VertexAttribs4hvNV(GLuint index, GLsizei n, IntPtr v)
-        {
-            VertexAttribs4hvNV_(index, n, v);
-        }
-
-        #endregion
-
-        #region VertexAttribs4hvNV(GLuint index, GLsizei n, object v)
-
-        public static
-        void VertexAttribs4hvNV(GLuint index, GLsizei n, object v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4hvNV_(index, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region VertexAttribs4hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
-
-        public static
-        void VertexAttribs4hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
-        {
-            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
-            try
-            {
-                VertexAttribs4hvNV_(index, n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region PixelDataRangeNV(GLenum target, GLsizei length, IntPtr pointer)
-
-        public static
-        void PixelDataRangeNV(GLenum target, GLsizei length, IntPtr pointer)
-        {
-            PixelDataRangeNV_(target, length, pointer);
-        }
-
-        #endregion
-
-        #region PixelDataRangeNV(GLenum target, GLsizei length, object pointer)
-
-        public static
-        void PixelDataRangeNV(GLenum target, GLsizei length, object pointer)
-        {
-            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
-            try
-            {
-                PixelDataRangeNV_(target, length, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetVertexAttribArrayObjectfvATI_(index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribArrayObjectfvATI_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat[] parameters)
-
-        public static
-        void GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribArrayObjectfvATI_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, IntPtr parameters)
-
-        public static
-        void GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, IntPtr parameters)
-        {
-            GetVertexAttribArrayObjectivATI_(index, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, object parameters)
-
-        public static
-        void GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribArrayObjectivATI_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint[] parameters)
-
-        public static
-        void GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetVertexAttribArrayObjectivATI_(index, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteRenderbuffersEXT(GLsizei n, IntPtr renderbuffers)
-
-        public static
-        void DeleteRenderbuffersEXT(GLsizei n, IntPtr renderbuffers)
-        {
-            DeleteRenderbuffersEXT_(n, renderbuffers);
-        }
-
-        #endregion
-
-        #region DeleteRenderbuffersEXT(GLsizei n, object renderbuffers)
-
-        public static
-        void DeleteRenderbuffersEXT(GLsizei n, object renderbuffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
-            try
-            {
-                DeleteRenderbuffersEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
-
-        public static
-        void DeleteRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
-            try
-            {
-                DeleteRenderbuffersEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenRenderbuffersEXT(GLsizei n, IntPtr renderbuffers)
-
-        public static
-        void GenRenderbuffersEXT(GLsizei n, IntPtr renderbuffers)
-        {
-            GenRenderbuffersEXT_(n, renderbuffers);
-        }
-
-        #endregion
-
-        #region GenRenderbuffersEXT(GLsizei n, object renderbuffers)
-
-        public static
-        void GenRenderbuffersEXT(GLsizei n, object renderbuffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
-            try
-            {
-                GenRenderbuffersEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
-
-        public static
-        void GenRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
-            try
-            {
-                GenRenderbuffersEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, IntPtr parameters)
-
-        public static
-        void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, IntPtr parameters)
-        {
-            GetRenderbufferParameterivEXT_(target, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, object parameters)
-
-        public static
-        void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetRenderbufferParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, GLint[] parameters)
-
-        public static
-        void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetRenderbufferParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteFramebuffersEXT(GLsizei n, IntPtr framebuffers)
-
-        public static
-        void DeleteFramebuffersEXT(GLsizei n, IntPtr framebuffers)
-        {
-            DeleteFramebuffersEXT_(n, framebuffers);
-        }
-
-        #endregion
-
-        #region DeleteFramebuffersEXT(GLsizei n, object framebuffers)
-
-        public static
-        void DeleteFramebuffersEXT(GLsizei n, object framebuffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
-            try
-            {
-                DeleteFramebuffersEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region DeleteFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
-
-        public static
-        void DeleteFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
-            try
-            {
-                DeleteFramebuffersEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenFramebuffersEXT(GLsizei n, IntPtr framebuffers)
-
-        public static
-        void GenFramebuffersEXT(GLsizei n, IntPtr framebuffers)
-        {
-            GenFramebuffersEXT_(n, framebuffers);
-        }
-
-        #endregion
-
-        #region GenFramebuffersEXT(GLsizei n, object framebuffers)
-
-        public static
-        void GenFramebuffersEXT(GLsizei n, object framebuffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
-            try
-            {
-                GenFramebuffersEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GenFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
-
-        public static
-        void GenFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
-        {
-            GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
-            try
-            {
-                GenFramebuffersEXT_(n, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, IntPtr parameters)
-
-        public static
-        void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, IntPtr parameters)
-        {
-            GetFramebufferAttachmentParameterivEXT_(target, attachment, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, object parameters)
-
-        public static
-        void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFramebufferAttachmentParameterivEXT_(target, attachment, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, GLint[] parameters)
-
-        public static
-        void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, GLint[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetFramebufferAttachmentParameterivEXT_(target, attachment, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region StringMarkerGREMEDY(GLsizei len, IntPtr @string)
-
-        public static
-        void StringMarkerGREMEDY(GLsizei len, IntPtr @string)
-        {
-            StringMarkerGREMEDY_(len, @string);
-        }
-
-        #endregion
-
-        #region StringMarkerGREMEDY(GLsizei len, object @string)
-
-        public static
-        void StringMarkerGREMEDY(GLsizei len, object @string)
-        {
-            GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
-            try
-            {
-                StringMarkerGREMEDY_(len, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters)
-
-        public static
-        void GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters)
-        {
-            GetQueryObjecti64vEXT_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, object parameters)
-
-        public static
-        void GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryObjecti64vEXT_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, GLint64[] parameters)
-
-        public static
-        void GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, GLint64[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryObjecti64vEXT_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters)
-
-        public static
-        void GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters)
-        {
-            GetQueryObjectui64vEXT_(id, pname, parameters);
-        }
-
-        #endregion
-
-        #region GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, object parameters)
-
-        public static
-        void GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryObjectui64vEXT_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, GLuint64[] parameters)
-
-        public static
-        void GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, GLuint64[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                GetQueryObjectui64vEXT_(id, pname, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, IntPtr parameters)
-
-        public static
-        void ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, IntPtr parameters)
-        {
-            ProgramEnvParameters4fvEXT_(target, index, count, parameters);
-        }
-
-        #endregion
-
-        #region ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, object parameters)
-
-        public static
-        void ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramEnvParameters4fvEXT_(target, index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat[] parameters)
-
-        public static
-        void ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramEnvParameters4fvEXT_(target, index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, IntPtr parameters)
-
-        public static
-        void ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, IntPtr parameters)
-        {
-            ProgramLocalParameters4fvEXT_(target, index, count, parameters);
-        }
-
-        #endregion
-
-        #region ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, object parameters)
-
-        public static
-        void ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, object parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramLocalParameters4fvEXT_(target, index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
-        #endregion
-
-        #region ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat[] parameters)
-
-        public static
-        void ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat[] parameters)
-        {
-            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
-            try
-            {
-                ProgramLocalParameters4fvEXT_(target, index, count, h0.AddrOfPinnedObject());
-            }
-            finally
-            {
-                h0.Free();
-            }
-        }
-
         #endregion
 
-        #endregion
+        #region static Constructor
+
+        static GL()
+        {
+            if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major < 6 || Environment.OSVersion.Platform == PlatformID.Win32Windows)
+            {
+                #region Older Windows Core
+                BlendColor = (Delegates.BlendColor)WindowsGetAddress("glBlendColor", typeof(Delegates.BlendColor));
+                BlendEquation = (Delegates.BlendEquation)WindowsGetAddress("glBlendEquation", typeof(Delegates.BlendEquation));
+                DrawRangeElements_ = (Delegates.DrawRangeElements_)WindowsGetAddress("glDrawRangeElements", typeof(Delegates.DrawRangeElements_));
+                ColorTable_ = (Delegates.ColorTable_)WindowsGetAddress("glColorTable", typeof(Delegates.ColorTable_));
+                ColorTableParameterfv_ = (Delegates.ColorTableParameterfv_)WindowsGetAddress("glColorTableParameterfv", typeof(Delegates.ColorTableParameterfv_));
+                ColorTableParameteriv_ = (Delegates.ColorTableParameteriv_)WindowsGetAddress("glColorTableParameteriv", typeof(Delegates.ColorTableParameteriv_));
+                CopyColorTable = (Delegates.CopyColorTable)WindowsGetAddress("glCopyColorTable", typeof(Delegates.CopyColorTable));
+                GetColorTable_ = (Delegates.GetColorTable_)WindowsGetAddress("glGetColorTable", typeof(Delegates.GetColorTable_));
+                GetColorTableParameterfv_ = (Delegates.GetColorTableParameterfv_)WindowsGetAddress("glGetColorTableParameterfv", typeof(Delegates.GetColorTableParameterfv_));
+                GetColorTableParameteriv_ = (Delegates.GetColorTableParameteriv_)WindowsGetAddress("glGetColorTableParameteriv", typeof(Delegates.GetColorTableParameteriv_));
+                ColorSubTable_ = (Delegates.ColorSubTable_)WindowsGetAddress("glColorSubTable", typeof(Delegates.ColorSubTable_));
+                CopyColorSubTable = (Delegates.CopyColorSubTable)WindowsGetAddress("glCopyColorSubTable", typeof(Delegates.CopyColorSubTable));
+                ConvolutionFilter1D_ = (Delegates.ConvolutionFilter1D_)WindowsGetAddress("glConvolutionFilter1D", typeof(Delegates.ConvolutionFilter1D_));
+                ConvolutionFilter2D_ = (Delegates.ConvolutionFilter2D_)WindowsGetAddress("glConvolutionFilter2D", typeof(Delegates.ConvolutionFilter2D_));
+                ConvolutionParameterf = (Delegates.ConvolutionParameterf)WindowsGetAddress("glConvolutionParameterf", typeof(Delegates.ConvolutionParameterf));
+                ConvolutionParameterfv_ = (Delegates.ConvolutionParameterfv_)WindowsGetAddress("glConvolutionParameterfv", typeof(Delegates.ConvolutionParameterfv_));
+                ConvolutionParameteri = (Delegates.ConvolutionParameteri)WindowsGetAddress("glConvolutionParameteri", typeof(Delegates.ConvolutionParameteri));
+                ConvolutionParameteriv_ = (Delegates.ConvolutionParameteriv_)WindowsGetAddress("glConvolutionParameteriv", typeof(Delegates.ConvolutionParameteriv_));
+                CopyConvolutionFilter1D = (Delegates.CopyConvolutionFilter1D)WindowsGetAddress("glCopyConvolutionFilter1D", typeof(Delegates.CopyConvolutionFilter1D));
+                CopyConvolutionFilter2D = (Delegates.CopyConvolutionFilter2D)WindowsGetAddress("glCopyConvolutionFilter2D", typeof(Delegates.CopyConvolutionFilter2D));
+                GetConvolutionFilter_ = (Delegates.GetConvolutionFilter_)WindowsGetAddress("glGetConvolutionFilter", typeof(Delegates.GetConvolutionFilter_));
+                GetConvolutionParameterfv_ = (Delegates.GetConvolutionParameterfv_)WindowsGetAddress("glGetConvolutionParameterfv", typeof(Delegates.GetConvolutionParameterfv_));
+                GetConvolutionParameteriv_ = (Delegates.GetConvolutionParameteriv_)WindowsGetAddress("glGetConvolutionParameteriv", typeof(Delegates.GetConvolutionParameteriv_));
+                GetSeparableFilter_ = (Delegates.GetSeparableFilter_)WindowsGetAddress("glGetSeparableFilter", typeof(Delegates.GetSeparableFilter_));
+                SeparableFilter2D_ = (Delegates.SeparableFilter2D_)WindowsGetAddress("glSeparableFilter2D", typeof(Delegates.SeparableFilter2D_));
+                GetHistogram_ = (Delegates.GetHistogram_)WindowsGetAddress("glGetHistogram", typeof(Delegates.GetHistogram_));
+                GetHistogramParameterfv_ = (Delegates.GetHistogramParameterfv_)WindowsGetAddress("glGetHistogramParameterfv", typeof(Delegates.GetHistogramParameterfv_));
+                GetHistogramParameteriv_ = (Delegates.GetHistogramParameteriv_)WindowsGetAddress("glGetHistogramParameteriv", typeof(Delegates.GetHistogramParameteriv_));
+                GetMinmax_ = (Delegates.GetMinmax_)WindowsGetAddress("glGetMinmax", typeof(Delegates.GetMinmax_));
+                GetMinmaxParameterfv_ = (Delegates.GetMinmaxParameterfv_)WindowsGetAddress("glGetMinmaxParameterfv", typeof(Delegates.GetMinmaxParameterfv_));
+                GetMinmaxParameteriv_ = (Delegates.GetMinmaxParameteriv_)WindowsGetAddress("glGetMinmaxParameteriv", typeof(Delegates.GetMinmaxParameteriv_));
+                Histogram = (Delegates.Histogram)WindowsGetAddress("glHistogram", typeof(Delegates.Histogram));
+                Minmax = (Delegates.Minmax)WindowsGetAddress("glMinmax", typeof(Delegates.Minmax));
+                ResetHistogram = (Delegates.ResetHistogram)WindowsGetAddress("glResetHistogram", typeof(Delegates.ResetHistogram));
+                ResetMinmax = (Delegates.ResetMinmax)WindowsGetAddress("glResetMinmax", typeof(Delegates.ResetMinmax));
+                TexImage3D_ = (Delegates.TexImage3D_)WindowsGetAddress("glTexImage3D", typeof(Delegates.TexImage3D_));
+                TexSubImage3D_ = (Delegates.TexSubImage3D_)WindowsGetAddress("glTexSubImage3D", typeof(Delegates.TexSubImage3D_));
+                CopyTexSubImage3D = (Delegates.CopyTexSubImage3D)WindowsGetAddress("glCopyTexSubImage3D", typeof(Delegates.CopyTexSubImage3D));
+                ActiveTexture = (Delegates.ActiveTexture)WindowsGetAddress("glActiveTexture", typeof(Delegates.ActiveTexture));
+                ClientActiveTexture = (Delegates.ClientActiveTexture)WindowsGetAddress("glClientActiveTexture", typeof(Delegates.ClientActiveTexture));
+                MultiTexCoord1d = (Delegates.MultiTexCoord1d)WindowsGetAddress("glMultiTexCoord1d", typeof(Delegates.MultiTexCoord1d));
+                MultiTexCoord1dv_ = (Delegates.MultiTexCoord1dv_)WindowsGetAddress("glMultiTexCoord1dv", typeof(Delegates.MultiTexCoord1dv_));
+                MultiTexCoord1f = (Delegates.MultiTexCoord1f)WindowsGetAddress("glMultiTexCoord1f", typeof(Delegates.MultiTexCoord1f));
+                MultiTexCoord1fv_ = (Delegates.MultiTexCoord1fv_)WindowsGetAddress("glMultiTexCoord1fv", typeof(Delegates.MultiTexCoord1fv_));
+                MultiTexCoord1i = (Delegates.MultiTexCoord1i)WindowsGetAddress("glMultiTexCoord1i", typeof(Delegates.MultiTexCoord1i));
+                MultiTexCoord1iv_ = (Delegates.MultiTexCoord1iv_)WindowsGetAddress("glMultiTexCoord1iv", typeof(Delegates.MultiTexCoord1iv_));
+                MultiTexCoord1s = (Delegates.MultiTexCoord1s)WindowsGetAddress("glMultiTexCoord1s", typeof(Delegates.MultiTexCoord1s));
+                MultiTexCoord1sv_ = (Delegates.MultiTexCoord1sv_)WindowsGetAddress("glMultiTexCoord1sv", typeof(Delegates.MultiTexCoord1sv_));
+                MultiTexCoord2d = (Delegates.MultiTexCoord2d)WindowsGetAddress("glMultiTexCoord2d", typeof(Delegates.MultiTexCoord2d));
+                MultiTexCoord2dv_ = (Delegates.MultiTexCoord2dv_)WindowsGetAddress("glMultiTexCoord2dv", typeof(Delegates.MultiTexCoord2dv_));
+                MultiTexCoord2f = (Delegates.MultiTexCoord2f)WindowsGetAddress("glMultiTexCoord2f", typeof(Delegates.MultiTexCoord2f));
+                MultiTexCoord2fv_ = (Delegates.MultiTexCoord2fv_)WindowsGetAddress("glMultiTexCoord2fv", typeof(Delegates.MultiTexCoord2fv_));
+                MultiTexCoord2i = (Delegates.MultiTexCoord2i)WindowsGetAddress("glMultiTexCoord2i", typeof(Delegates.MultiTexCoord2i));
+                MultiTexCoord2iv_ = (Delegates.MultiTexCoord2iv_)WindowsGetAddress("glMultiTexCoord2iv", typeof(Delegates.MultiTexCoord2iv_));
+                MultiTexCoord2s = (Delegates.MultiTexCoord2s)WindowsGetAddress("glMultiTexCoord2s", typeof(Delegates.MultiTexCoord2s));
+                MultiTexCoord2sv_ = (Delegates.MultiTexCoord2sv_)WindowsGetAddress("glMultiTexCoord2sv", typeof(Delegates.MultiTexCoord2sv_));
+                MultiTexCoord3d = (Delegates.MultiTexCoord3d)WindowsGetAddress("glMultiTexCoord3d", typeof(Delegates.MultiTexCoord3d));
+                MultiTexCoord3dv_ = (Delegates.MultiTexCoord3dv_)WindowsGetAddress("glMultiTexCoord3dv", typeof(Delegates.MultiTexCoord3dv_));
+                MultiTexCoord3f = (Delegates.MultiTexCoord3f)WindowsGetAddress("glMultiTexCoord3f", typeof(Delegates.MultiTexCoord3f));
+                MultiTexCoord3fv_ = (Delegates.MultiTexCoord3fv_)WindowsGetAddress("glMultiTexCoord3fv", typeof(Delegates.MultiTexCoord3fv_));
+                MultiTexCoord3i = (Delegates.MultiTexCoord3i)WindowsGetAddress("glMultiTexCoord3i", typeof(Delegates.MultiTexCoord3i));
+                MultiTexCoord3iv_ = (Delegates.MultiTexCoord3iv_)WindowsGetAddress("glMultiTexCoord3iv", typeof(Delegates.MultiTexCoord3iv_));
+                MultiTexCoord3s = (Delegates.MultiTexCoord3s)WindowsGetAddress("glMultiTexCoord3s", typeof(Delegates.MultiTexCoord3s));
+                MultiTexCoord3sv_ = (Delegates.MultiTexCoord3sv_)WindowsGetAddress("glMultiTexCoord3sv", typeof(Delegates.MultiTexCoord3sv_));
+                MultiTexCoord4d = (Delegates.MultiTexCoord4d)WindowsGetAddress("glMultiTexCoord4d", typeof(Delegates.MultiTexCoord4d));
+                MultiTexCoord4dv_ = (Delegates.MultiTexCoord4dv_)WindowsGetAddress("glMultiTexCoord4dv", typeof(Delegates.MultiTexCoord4dv_));
+                MultiTexCoord4f = (Delegates.MultiTexCoord4f)WindowsGetAddress("glMultiTexCoord4f", typeof(Delegates.MultiTexCoord4f));
+                MultiTexCoord4fv_ = (Delegates.MultiTexCoord4fv_)WindowsGetAddress("glMultiTexCoord4fv", typeof(Delegates.MultiTexCoord4fv_));
+                MultiTexCoord4i = (Delegates.MultiTexCoord4i)WindowsGetAddress("glMultiTexCoord4i", typeof(Delegates.MultiTexCoord4i));
+                MultiTexCoord4iv_ = (Delegates.MultiTexCoord4iv_)WindowsGetAddress("glMultiTexCoord4iv", typeof(Delegates.MultiTexCoord4iv_));
+                MultiTexCoord4s = (Delegates.MultiTexCoord4s)WindowsGetAddress("glMultiTexCoord4s", typeof(Delegates.MultiTexCoord4s));
+                MultiTexCoord4sv_ = (Delegates.MultiTexCoord4sv_)WindowsGetAddress("glMultiTexCoord4sv", typeof(Delegates.MultiTexCoord4sv_));
+                LoadTransposeMatrixf_ = (Delegates.LoadTransposeMatrixf_)WindowsGetAddress("glLoadTransposeMatrixf", typeof(Delegates.LoadTransposeMatrixf_));
+                LoadTransposeMatrixd_ = (Delegates.LoadTransposeMatrixd_)WindowsGetAddress("glLoadTransposeMatrixd", typeof(Delegates.LoadTransposeMatrixd_));
+                MultTransposeMatrixf_ = (Delegates.MultTransposeMatrixf_)WindowsGetAddress("glMultTransposeMatrixf", typeof(Delegates.MultTransposeMatrixf_));
+                MultTransposeMatrixd_ = (Delegates.MultTransposeMatrixd_)WindowsGetAddress("glMultTransposeMatrixd", typeof(Delegates.MultTransposeMatrixd_));
+                SampleCoverage = (Delegates.SampleCoverage)WindowsGetAddress("glSampleCoverage", typeof(Delegates.SampleCoverage));
+                CompressedTexImage3D_ = (Delegates.CompressedTexImage3D_)WindowsGetAddress("glCompressedTexImage3D", typeof(Delegates.CompressedTexImage3D_));
+                CompressedTexImage2D_ = (Delegates.CompressedTexImage2D_)WindowsGetAddress("glCompressedTexImage2D", typeof(Delegates.CompressedTexImage2D_));
+                CompressedTexImage1D_ = (Delegates.CompressedTexImage1D_)WindowsGetAddress("glCompressedTexImage1D", typeof(Delegates.CompressedTexImage1D_));
+                CompressedTexSubImage3D_ = (Delegates.CompressedTexSubImage3D_)WindowsGetAddress("glCompressedTexSubImage3D", typeof(Delegates.CompressedTexSubImage3D_));
+                CompressedTexSubImage2D_ = (Delegates.CompressedTexSubImage2D_)WindowsGetAddress("glCompressedTexSubImage2D", typeof(Delegates.CompressedTexSubImage2D_));
+                CompressedTexSubImage1D_ = (Delegates.CompressedTexSubImage1D_)WindowsGetAddress("glCompressedTexSubImage1D", typeof(Delegates.CompressedTexSubImage1D_));
+                GetCompressedTexImage_ = (Delegates.GetCompressedTexImage_)WindowsGetAddress("glGetCompressedTexImage", typeof(Delegates.GetCompressedTexImage_));
+                BlendFuncSeparate = (Delegates.BlendFuncSeparate)WindowsGetAddress("glBlendFuncSeparate", typeof(Delegates.BlendFuncSeparate));
+                FogCoordf = (Delegates.FogCoordf)WindowsGetAddress("glFogCoordf", typeof(Delegates.FogCoordf));
+                FogCoordfv_ = (Delegates.FogCoordfv_)WindowsGetAddress("glFogCoordfv", typeof(Delegates.FogCoordfv_));
+                FogCoordd = (Delegates.FogCoordd)WindowsGetAddress("glFogCoordd", typeof(Delegates.FogCoordd));
+                FogCoorddv_ = (Delegates.FogCoorddv_)WindowsGetAddress("glFogCoorddv", typeof(Delegates.FogCoorddv_));
+                FogCoordPointer_ = (Delegates.FogCoordPointer_)WindowsGetAddress("glFogCoordPointer", typeof(Delegates.FogCoordPointer_));
+                MultiDrawArrays_ = (Delegates.MultiDrawArrays_)WindowsGetAddress("glMultiDrawArrays", typeof(Delegates.MultiDrawArrays_));
+                MultiDrawElements_ = (Delegates.MultiDrawElements_)WindowsGetAddress("glMultiDrawElements", typeof(Delegates.MultiDrawElements_));
+                PointParameterf = (Delegates.PointParameterf)WindowsGetAddress("glPointParameterf", typeof(Delegates.PointParameterf));
+                PointParameterfv_ = (Delegates.PointParameterfv_)WindowsGetAddress("glPointParameterfv", typeof(Delegates.PointParameterfv_));
+                PointParameteri = (Delegates.PointParameteri)WindowsGetAddress("glPointParameteri", typeof(Delegates.PointParameteri));
+                PointParameteriv_ = (Delegates.PointParameteriv_)WindowsGetAddress("glPointParameteriv", typeof(Delegates.PointParameteriv_));
+                SecondaryColor3b = (Delegates.SecondaryColor3b)WindowsGetAddress("glSecondaryColor3b", typeof(Delegates.SecondaryColor3b));
+                SecondaryColor3bv_ = (Delegates.SecondaryColor3bv_)WindowsGetAddress("glSecondaryColor3bv", typeof(Delegates.SecondaryColor3bv_));
+                SecondaryColor3d = (Delegates.SecondaryColor3d)WindowsGetAddress("glSecondaryColor3d", typeof(Delegates.SecondaryColor3d));
+                SecondaryColor3dv_ = (Delegates.SecondaryColor3dv_)WindowsGetAddress("glSecondaryColor3dv", typeof(Delegates.SecondaryColor3dv_));
+                SecondaryColor3f = (Delegates.SecondaryColor3f)WindowsGetAddress("glSecondaryColor3f", typeof(Delegates.SecondaryColor3f));
+                SecondaryColor3fv_ = (Delegates.SecondaryColor3fv_)WindowsGetAddress("glSecondaryColor3fv", typeof(Delegates.SecondaryColor3fv_));
+                SecondaryColor3i = (Delegates.SecondaryColor3i)WindowsGetAddress("glSecondaryColor3i", typeof(Delegates.SecondaryColor3i));
+                SecondaryColor3iv_ = (Delegates.SecondaryColor3iv_)WindowsGetAddress("glSecondaryColor3iv", typeof(Delegates.SecondaryColor3iv_));
+                SecondaryColor3s = (Delegates.SecondaryColor3s)WindowsGetAddress("glSecondaryColor3s", typeof(Delegates.SecondaryColor3s));
+                SecondaryColor3sv_ = (Delegates.SecondaryColor3sv_)WindowsGetAddress("glSecondaryColor3sv", typeof(Delegates.SecondaryColor3sv_));
+                SecondaryColor3ub = (Delegates.SecondaryColor3ub)WindowsGetAddress("glSecondaryColor3ub", typeof(Delegates.SecondaryColor3ub));
+                SecondaryColor3ubv_ = (Delegates.SecondaryColor3ubv_)WindowsGetAddress("glSecondaryColor3ubv", typeof(Delegates.SecondaryColor3ubv_));
+                SecondaryColor3ui = (Delegates.SecondaryColor3ui)WindowsGetAddress("glSecondaryColor3ui", typeof(Delegates.SecondaryColor3ui));
+                SecondaryColor3uiv_ = (Delegates.SecondaryColor3uiv_)WindowsGetAddress("glSecondaryColor3uiv", typeof(Delegates.SecondaryColor3uiv_));
+                SecondaryColor3us = (Delegates.SecondaryColor3us)WindowsGetAddress("glSecondaryColor3us", typeof(Delegates.SecondaryColor3us));
+                SecondaryColor3usv_ = (Delegates.SecondaryColor3usv_)WindowsGetAddress("glSecondaryColor3usv", typeof(Delegates.SecondaryColor3usv_));
+                SecondaryColorPointer_ = (Delegates.SecondaryColorPointer_)WindowsGetAddress("glSecondaryColorPointer", typeof(Delegates.SecondaryColorPointer_));
+                WindowPos2d = (Delegates.WindowPos2d)WindowsGetAddress("glWindowPos2d", typeof(Delegates.WindowPos2d));
+                WindowPos2dv_ = (Delegates.WindowPos2dv_)WindowsGetAddress("glWindowPos2dv", typeof(Delegates.WindowPos2dv_));
+                WindowPos2f = (Delegates.WindowPos2f)WindowsGetAddress("glWindowPos2f", typeof(Delegates.WindowPos2f));
+                WindowPos2fv_ = (Delegates.WindowPos2fv_)WindowsGetAddress("glWindowPos2fv", typeof(Delegates.WindowPos2fv_));
+                WindowPos2i = (Delegates.WindowPos2i)WindowsGetAddress("glWindowPos2i", typeof(Delegates.WindowPos2i));
+                WindowPos2iv_ = (Delegates.WindowPos2iv_)WindowsGetAddress("glWindowPos2iv", typeof(Delegates.WindowPos2iv_));
+                WindowPos2s = (Delegates.WindowPos2s)WindowsGetAddress("glWindowPos2s", typeof(Delegates.WindowPos2s));
+                WindowPos2sv_ = (Delegates.WindowPos2sv_)WindowsGetAddress("glWindowPos2sv", typeof(Delegates.WindowPos2sv_));
+                WindowPos3d = (Delegates.WindowPos3d)WindowsGetAddress("glWindowPos3d", typeof(Delegates.WindowPos3d));
+                WindowPos3dv_ = (Delegates.WindowPos3dv_)WindowsGetAddress("glWindowPos3dv", typeof(Delegates.WindowPos3dv_));
+                WindowPos3f = (Delegates.WindowPos3f)WindowsGetAddress("glWindowPos3f", typeof(Delegates.WindowPos3f));
+                WindowPos3fv_ = (Delegates.WindowPos3fv_)WindowsGetAddress("glWindowPos3fv", typeof(Delegates.WindowPos3fv_));
+                WindowPos3i = (Delegates.WindowPos3i)WindowsGetAddress("glWindowPos3i", typeof(Delegates.WindowPos3i));
+                WindowPos3iv_ = (Delegates.WindowPos3iv_)WindowsGetAddress("glWindowPos3iv", typeof(Delegates.WindowPos3iv_));
+                WindowPos3s = (Delegates.WindowPos3s)WindowsGetAddress("glWindowPos3s", typeof(Delegates.WindowPos3s));
+                WindowPos3sv_ = (Delegates.WindowPos3sv_)WindowsGetAddress("glWindowPos3sv", typeof(Delegates.WindowPos3sv_));
+                GenQueries_ = (Delegates.GenQueries_)WindowsGetAddress("glGenQueries", typeof(Delegates.GenQueries_));
+                DeleteQueries_ = (Delegates.DeleteQueries_)WindowsGetAddress("glDeleteQueries", typeof(Delegates.DeleteQueries_));
+                IsQuery = (Delegates.IsQuery)WindowsGetAddress("glIsQuery", typeof(Delegates.IsQuery));
+                BeginQuery = (Delegates.BeginQuery)WindowsGetAddress("glBeginQuery", typeof(Delegates.BeginQuery));
+                EndQuery = (Delegates.EndQuery)WindowsGetAddress("glEndQuery", typeof(Delegates.EndQuery));
+                GetQueryiv_ = (Delegates.GetQueryiv_)WindowsGetAddress("glGetQueryiv", typeof(Delegates.GetQueryiv_));
+                GetQueryObjectiv_ = (Delegates.GetQueryObjectiv_)WindowsGetAddress("glGetQueryObjectiv", typeof(Delegates.GetQueryObjectiv_));
+                GetQueryObjectuiv_ = (Delegates.GetQueryObjectuiv_)WindowsGetAddress("glGetQueryObjectuiv", typeof(Delegates.GetQueryObjectuiv_));
+                BindBuffer = (Delegates.BindBuffer)WindowsGetAddress("glBindBuffer", typeof(Delegates.BindBuffer));
+                DeleteBuffers_ = (Delegates.DeleteBuffers_)WindowsGetAddress("glDeleteBuffers", typeof(Delegates.DeleteBuffers_));
+                GenBuffers_ = (Delegates.GenBuffers_)WindowsGetAddress("glGenBuffers", typeof(Delegates.GenBuffers_));
+                IsBuffer = (Delegates.IsBuffer)WindowsGetAddress("glIsBuffer", typeof(Delegates.IsBuffer));
+                BufferData_ = (Delegates.BufferData_)WindowsGetAddress("glBufferData", typeof(Delegates.BufferData_));
+                BufferSubData_ = (Delegates.BufferSubData_)WindowsGetAddress("glBufferSubData", typeof(Delegates.BufferSubData_));
+                GetBufferSubData_ = (Delegates.GetBufferSubData_)WindowsGetAddress("glGetBufferSubData", typeof(Delegates.GetBufferSubData_));
+                MapBuffer = (Delegates.MapBuffer)WindowsGetAddress("glMapBuffer", typeof(Delegates.MapBuffer));
+                UnmapBuffer = (Delegates.UnmapBuffer)WindowsGetAddress("glUnmapBuffer", typeof(Delegates.UnmapBuffer));
+                GetBufferParameteriv_ = (Delegates.GetBufferParameteriv_)WindowsGetAddress("glGetBufferParameteriv", typeof(Delegates.GetBufferParameteriv_));
+                GetBufferPointerv_ = (Delegates.GetBufferPointerv_)WindowsGetAddress("glGetBufferPointerv", typeof(Delegates.GetBufferPointerv_));
+                BlendEquationSeparate = (Delegates.BlendEquationSeparate)WindowsGetAddress("glBlendEquationSeparate", typeof(Delegates.BlendEquationSeparate));
+                DrawBuffers_ = (Delegates.DrawBuffers_)WindowsGetAddress("glDrawBuffers", typeof(Delegates.DrawBuffers_));
+                StencilOpSeparate = (Delegates.StencilOpSeparate)WindowsGetAddress("glStencilOpSeparate", typeof(Delegates.StencilOpSeparate));
+                StencilFuncSeparate = (Delegates.StencilFuncSeparate)WindowsGetAddress("glStencilFuncSeparate", typeof(Delegates.StencilFuncSeparate));
+                StencilMaskSeparate = (Delegates.StencilMaskSeparate)WindowsGetAddress("glStencilMaskSeparate", typeof(Delegates.StencilMaskSeparate));
+                AttachShader = (Delegates.AttachShader)WindowsGetAddress("glAttachShader", typeof(Delegates.AttachShader));
+                BindAttribLocation = (Delegates.BindAttribLocation)WindowsGetAddress("glBindAttribLocation", typeof(Delegates.BindAttribLocation));
+                CompileShader = (Delegates.CompileShader)WindowsGetAddress("glCompileShader", typeof(Delegates.CompileShader));
+                CreateProgram = (Delegates.CreateProgram)WindowsGetAddress("glCreateProgram", typeof(Delegates.CreateProgram));
+                CreateShader = (Delegates.CreateShader)WindowsGetAddress("glCreateShader", typeof(Delegates.CreateShader));
+                DeleteProgram = (Delegates.DeleteProgram)WindowsGetAddress("glDeleteProgram", typeof(Delegates.DeleteProgram));
+                DeleteShader = (Delegates.DeleteShader)WindowsGetAddress("glDeleteShader", typeof(Delegates.DeleteShader));
+                DetachShader = (Delegates.DetachShader)WindowsGetAddress("glDetachShader", typeof(Delegates.DetachShader));
+                DisableVertexAttribArray = (Delegates.DisableVertexAttribArray)WindowsGetAddress("glDisableVertexAttribArray", typeof(Delegates.DisableVertexAttribArray));
+                EnableVertexAttribArray = (Delegates.EnableVertexAttribArray)WindowsGetAddress("glEnableVertexAttribArray", typeof(Delegates.EnableVertexAttribArray));
+                GetActiveAttrib_ = (Delegates.GetActiveAttrib_)WindowsGetAddress("glGetActiveAttrib", typeof(Delegates.GetActiveAttrib_));
+                GetActiveUniform_ = (Delegates.GetActiveUniform_)WindowsGetAddress("glGetActiveUniform", typeof(Delegates.GetActiveUniform_));
+                GetAttachedShaders_ = (Delegates.GetAttachedShaders_)WindowsGetAddress("glGetAttachedShaders", typeof(Delegates.GetAttachedShaders_));
+                GetAttribLocation = (Delegates.GetAttribLocation)WindowsGetAddress("glGetAttribLocation", typeof(Delegates.GetAttribLocation));
+                GetProgramiv_ = (Delegates.GetProgramiv_)WindowsGetAddress("glGetProgramiv", typeof(Delegates.GetProgramiv_));
+                GetProgramInfoLog_ = (Delegates.GetProgramInfoLog_)WindowsGetAddress("glGetProgramInfoLog", typeof(Delegates.GetProgramInfoLog_));
+                GetShaderiv_ = (Delegates.GetShaderiv_)WindowsGetAddress("glGetShaderiv", typeof(Delegates.GetShaderiv_));
+                GetShaderInfoLog_ = (Delegates.GetShaderInfoLog_)WindowsGetAddress("glGetShaderInfoLog", typeof(Delegates.GetShaderInfoLog_));
+                GetShaderSource_ = (Delegates.GetShaderSource_)WindowsGetAddress("glGetShaderSource", typeof(Delegates.GetShaderSource_));
+                GetUniformLocation = (Delegates.GetUniformLocation)WindowsGetAddress("glGetUniformLocation", typeof(Delegates.GetUniformLocation));
+                GetUniformfv_ = (Delegates.GetUniformfv_)WindowsGetAddress("glGetUniformfv", typeof(Delegates.GetUniformfv_));
+                GetUniformiv_ = (Delegates.GetUniformiv_)WindowsGetAddress("glGetUniformiv", typeof(Delegates.GetUniformiv_));
+                GetVertexAttribdv_ = (Delegates.GetVertexAttribdv_)WindowsGetAddress("glGetVertexAttribdv", typeof(Delegates.GetVertexAttribdv_));
+                GetVertexAttribfv_ = (Delegates.GetVertexAttribfv_)WindowsGetAddress("glGetVertexAttribfv", typeof(Delegates.GetVertexAttribfv_));
+                GetVertexAttribiv_ = (Delegates.GetVertexAttribiv_)WindowsGetAddress("glGetVertexAttribiv", typeof(Delegates.GetVertexAttribiv_));
+                GetVertexAttribPointerv_ = (Delegates.GetVertexAttribPointerv_)WindowsGetAddress("glGetVertexAttribPointerv", typeof(Delegates.GetVertexAttribPointerv_));
+                IsProgram = (Delegates.IsProgram)WindowsGetAddress("glIsProgram", typeof(Delegates.IsProgram));
+                IsShader = (Delegates.IsShader)WindowsGetAddress("glIsShader", typeof(Delegates.IsShader));
+                LinkProgram = (Delegates.LinkProgram)WindowsGetAddress("glLinkProgram", typeof(Delegates.LinkProgram));
+                ShaderSource_ = (Delegates.ShaderSource_)WindowsGetAddress("glShaderSource", typeof(Delegates.ShaderSource_));
+                UseProgram = (Delegates.UseProgram)WindowsGetAddress("glUseProgram", typeof(Delegates.UseProgram));
+                Uniform1f = (Delegates.Uniform1f)WindowsGetAddress("glUniform1f", typeof(Delegates.Uniform1f));
+                Uniform2f = (Delegates.Uniform2f)WindowsGetAddress("glUniform2f", typeof(Delegates.Uniform2f));
+                Uniform3f = (Delegates.Uniform3f)WindowsGetAddress("glUniform3f", typeof(Delegates.Uniform3f));
+                Uniform4f = (Delegates.Uniform4f)WindowsGetAddress("glUniform4f", typeof(Delegates.Uniform4f));
+                Uniform1i = (Delegates.Uniform1i)WindowsGetAddress("glUniform1i", typeof(Delegates.Uniform1i));
+                Uniform2i = (Delegates.Uniform2i)WindowsGetAddress("glUniform2i", typeof(Delegates.Uniform2i));
+                Uniform3i = (Delegates.Uniform3i)WindowsGetAddress("glUniform3i", typeof(Delegates.Uniform3i));
+                Uniform4i = (Delegates.Uniform4i)WindowsGetAddress("glUniform4i", typeof(Delegates.Uniform4i));
+                Uniform1fv_ = (Delegates.Uniform1fv_)WindowsGetAddress("glUniform1fv", typeof(Delegates.Uniform1fv_));
+                Uniform2fv_ = (Delegates.Uniform2fv_)WindowsGetAddress("glUniform2fv", typeof(Delegates.Uniform2fv_));
+                Uniform3fv_ = (Delegates.Uniform3fv_)WindowsGetAddress("glUniform3fv", typeof(Delegates.Uniform3fv_));
+                Uniform4fv_ = (Delegates.Uniform4fv_)WindowsGetAddress("glUniform4fv", typeof(Delegates.Uniform4fv_));
+                Uniform1iv_ = (Delegates.Uniform1iv_)WindowsGetAddress("glUniform1iv", typeof(Delegates.Uniform1iv_));
+                Uniform2iv_ = (Delegates.Uniform2iv_)WindowsGetAddress("glUniform2iv", typeof(Delegates.Uniform2iv_));
+                Uniform3iv_ = (Delegates.Uniform3iv_)WindowsGetAddress("glUniform3iv", typeof(Delegates.Uniform3iv_));
+                Uniform4iv_ = (Delegates.Uniform4iv_)WindowsGetAddress("glUniform4iv", typeof(Delegates.Uniform4iv_));
+                UniformMatrix2fv_ = (Delegates.UniformMatrix2fv_)WindowsGetAddress("glUniformMatrix2fv", typeof(Delegates.UniformMatrix2fv_));
+                UniformMatrix3fv_ = (Delegates.UniformMatrix3fv_)WindowsGetAddress("glUniformMatrix3fv", typeof(Delegates.UniformMatrix3fv_));
+                UniformMatrix4fv_ = (Delegates.UniformMatrix4fv_)WindowsGetAddress("glUniformMatrix4fv", typeof(Delegates.UniformMatrix4fv_));
+                ValidateProgram = (Delegates.ValidateProgram)WindowsGetAddress("glValidateProgram", typeof(Delegates.ValidateProgram));
+                VertexAttrib1d = (Delegates.VertexAttrib1d)WindowsGetAddress("glVertexAttrib1d", typeof(Delegates.VertexAttrib1d));
+                VertexAttrib1dv_ = (Delegates.VertexAttrib1dv_)WindowsGetAddress("glVertexAttrib1dv", typeof(Delegates.VertexAttrib1dv_));
+                VertexAttrib1f = (Delegates.VertexAttrib1f)WindowsGetAddress("glVertexAttrib1f", typeof(Delegates.VertexAttrib1f));
+                VertexAttrib1fv_ = (Delegates.VertexAttrib1fv_)WindowsGetAddress("glVertexAttrib1fv", typeof(Delegates.VertexAttrib1fv_));
+                VertexAttrib1s = (Delegates.VertexAttrib1s)WindowsGetAddress("glVertexAttrib1s", typeof(Delegates.VertexAttrib1s));
+                VertexAttrib1sv_ = (Delegates.VertexAttrib1sv_)WindowsGetAddress("glVertexAttrib1sv", typeof(Delegates.VertexAttrib1sv_));
+                VertexAttrib2d = (Delegates.VertexAttrib2d)WindowsGetAddress("glVertexAttrib2d", typeof(Delegates.VertexAttrib2d));
+                VertexAttrib2dv_ = (Delegates.VertexAttrib2dv_)WindowsGetAddress("glVertexAttrib2dv", typeof(Delegates.VertexAttrib2dv_));
+                VertexAttrib2f = (Delegates.VertexAttrib2f)WindowsGetAddress("glVertexAttrib2f", typeof(Delegates.VertexAttrib2f));
+                VertexAttrib2fv_ = (Delegates.VertexAttrib2fv_)WindowsGetAddress("glVertexAttrib2fv", typeof(Delegates.VertexAttrib2fv_));
+                VertexAttrib2s = (Delegates.VertexAttrib2s)WindowsGetAddress("glVertexAttrib2s", typeof(Delegates.VertexAttrib2s));
+                VertexAttrib2sv_ = (Delegates.VertexAttrib2sv_)WindowsGetAddress("glVertexAttrib2sv", typeof(Delegates.VertexAttrib2sv_));
+                VertexAttrib3d = (Delegates.VertexAttrib3d)WindowsGetAddress("glVertexAttrib3d", typeof(Delegates.VertexAttrib3d));
+                VertexAttrib3dv_ = (Delegates.VertexAttrib3dv_)WindowsGetAddress("glVertexAttrib3dv", typeof(Delegates.VertexAttrib3dv_));
+                VertexAttrib3f = (Delegates.VertexAttrib3f)WindowsGetAddress("glVertexAttrib3f", typeof(Delegates.VertexAttrib3f));
+                VertexAttrib3fv_ = (Delegates.VertexAttrib3fv_)WindowsGetAddress("glVertexAttrib3fv", typeof(Delegates.VertexAttrib3fv_));
+                VertexAttrib3s = (Delegates.VertexAttrib3s)WindowsGetAddress("glVertexAttrib3s", typeof(Delegates.VertexAttrib3s));
+                VertexAttrib3sv_ = (Delegates.VertexAttrib3sv_)WindowsGetAddress("glVertexAttrib3sv", typeof(Delegates.VertexAttrib3sv_));
+                VertexAttrib4Nbv_ = (Delegates.VertexAttrib4Nbv_)WindowsGetAddress("glVertexAttrib4Nbv", typeof(Delegates.VertexAttrib4Nbv_));
+                VertexAttrib4Niv_ = (Delegates.VertexAttrib4Niv_)WindowsGetAddress("glVertexAttrib4Niv", typeof(Delegates.VertexAttrib4Niv_));
+                VertexAttrib4Nsv_ = (Delegates.VertexAttrib4Nsv_)WindowsGetAddress("glVertexAttrib4Nsv", typeof(Delegates.VertexAttrib4Nsv_));
+                VertexAttrib4Nub = (Delegates.VertexAttrib4Nub)WindowsGetAddress("glVertexAttrib4Nub", typeof(Delegates.VertexAttrib4Nub));
+                VertexAttrib4Nubv_ = (Delegates.VertexAttrib4Nubv_)WindowsGetAddress("glVertexAttrib4Nubv", typeof(Delegates.VertexAttrib4Nubv_));
+                VertexAttrib4Nuiv_ = (Delegates.VertexAttrib4Nuiv_)WindowsGetAddress("glVertexAttrib4Nuiv", typeof(Delegates.VertexAttrib4Nuiv_));
+                VertexAttrib4Nusv_ = (Delegates.VertexAttrib4Nusv_)WindowsGetAddress("glVertexAttrib4Nusv", typeof(Delegates.VertexAttrib4Nusv_));
+                VertexAttrib4bv_ = (Delegates.VertexAttrib4bv_)WindowsGetAddress("glVertexAttrib4bv", typeof(Delegates.VertexAttrib4bv_));
+                VertexAttrib4d = (Delegates.VertexAttrib4d)WindowsGetAddress("glVertexAttrib4d", typeof(Delegates.VertexAttrib4d));
+                VertexAttrib4dv_ = (Delegates.VertexAttrib4dv_)WindowsGetAddress("glVertexAttrib4dv", typeof(Delegates.VertexAttrib4dv_));
+                VertexAttrib4f = (Delegates.VertexAttrib4f)WindowsGetAddress("glVertexAttrib4f", typeof(Delegates.VertexAttrib4f));
+                VertexAttrib4fv_ = (Delegates.VertexAttrib4fv_)WindowsGetAddress("glVertexAttrib4fv", typeof(Delegates.VertexAttrib4fv_));
+                VertexAttrib4iv_ = (Delegates.VertexAttrib4iv_)WindowsGetAddress("glVertexAttrib4iv", typeof(Delegates.VertexAttrib4iv_));
+                VertexAttrib4s = (Delegates.VertexAttrib4s)WindowsGetAddress("glVertexAttrib4s", typeof(Delegates.VertexAttrib4s));
+                VertexAttrib4sv_ = (Delegates.VertexAttrib4sv_)WindowsGetAddress("glVertexAttrib4sv", typeof(Delegates.VertexAttrib4sv_));
+                VertexAttrib4ubv_ = (Delegates.VertexAttrib4ubv_)WindowsGetAddress("glVertexAttrib4ubv", typeof(Delegates.VertexAttrib4ubv_));
+                VertexAttrib4uiv_ = (Delegates.VertexAttrib4uiv_)WindowsGetAddress("glVertexAttrib4uiv", typeof(Delegates.VertexAttrib4uiv_));
+                VertexAttrib4usv_ = (Delegates.VertexAttrib4usv_)WindowsGetAddress("glVertexAttrib4usv", typeof(Delegates.VertexAttrib4usv_));
+                VertexAttribPointer_ = (Delegates.VertexAttribPointer_)WindowsGetAddress("glVertexAttribPointer", typeof(Delegates.VertexAttribPointer_));
+                UniformMatrix2x3fv_ = (Delegates.UniformMatrix2x3fv_)WindowsGetAddress("glUniformMatrix2x3fv", typeof(Delegates.UniformMatrix2x3fv_));
+                UniformMatrix3x2fv_ = (Delegates.UniformMatrix3x2fv_)WindowsGetAddress("glUniformMatrix3x2fv", typeof(Delegates.UniformMatrix3x2fv_));
+                UniformMatrix2x4fv_ = (Delegates.UniformMatrix2x4fv_)WindowsGetAddress("glUniformMatrix2x4fv", typeof(Delegates.UniformMatrix2x4fv_));
+                UniformMatrix4x2fv_ = (Delegates.UniformMatrix4x2fv_)WindowsGetAddress("glUniformMatrix4x2fv", typeof(Delegates.UniformMatrix4x2fv_));
+                UniformMatrix3x4fv_ = (Delegates.UniformMatrix3x4fv_)WindowsGetAddress("glUniformMatrix3x4fv", typeof(Delegates.UniformMatrix3x4fv_));
+                UniformMatrix4x3fv_ = (Delegates.UniformMatrix4x3fv_)WindowsGetAddress("glUniformMatrix4x3fv", typeof(Delegates.UniformMatrix4x3fv_));
+                #endregion Older Windows Core
+            }
+            else if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major >= 6)
+            {
+                #region Windows Vista Core
+                GenQueries_ = (Delegates.GenQueries_)WindowsGetAddress("glGenQueries", typeof(Delegates.GenQueries_));
+                DeleteQueries_ = (Delegates.DeleteQueries_)WindowsGetAddress("glDeleteQueries", typeof(Delegates.DeleteQueries_));
+                IsQuery = (Delegates.IsQuery)WindowsGetAddress("glIsQuery", typeof(Delegates.IsQuery));
+                BeginQuery = (Delegates.BeginQuery)WindowsGetAddress("glBeginQuery", typeof(Delegates.BeginQuery));
+                EndQuery = (Delegates.EndQuery)WindowsGetAddress("glEndQuery", typeof(Delegates.EndQuery));
+                GetQueryiv_ = (Delegates.GetQueryiv_)WindowsGetAddress("glGetQueryiv", typeof(Delegates.GetQueryiv_));
+                GetQueryObjectiv_ = (Delegates.GetQueryObjectiv_)WindowsGetAddress("glGetQueryObjectiv", typeof(Delegates.GetQueryObjectiv_));
+                GetQueryObjectuiv_ = (Delegates.GetQueryObjectuiv_)WindowsGetAddress("glGetQueryObjectuiv", typeof(Delegates.GetQueryObjectuiv_));
+                BindBuffer = (Delegates.BindBuffer)WindowsGetAddress("glBindBuffer", typeof(Delegates.BindBuffer));
+                DeleteBuffers_ = (Delegates.DeleteBuffers_)WindowsGetAddress("glDeleteBuffers", typeof(Delegates.DeleteBuffers_));
+                GenBuffers_ = (Delegates.GenBuffers_)WindowsGetAddress("glGenBuffers", typeof(Delegates.GenBuffers_));
+                IsBuffer = (Delegates.IsBuffer)WindowsGetAddress("glIsBuffer", typeof(Delegates.IsBuffer));
+                BufferData_ = (Delegates.BufferData_)WindowsGetAddress("glBufferData", typeof(Delegates.BufferData_));
+                BufferSubData_ = (Delegates.BufferSubData_)WindowsGetAddress("glBufferSubData", typeof(Delegates.BufferSubData_));
+                GetBufferSubData_ = (Delegates.GetBufferSubData_)WindowsGetAddress("glGetBufferSubData", typeof(Delegates.GetBufferSubData_));
+                MapBuffer = (Delegates.MapBuffer)WindowsGetAddress("glMapBuffer", typeof(Delegates.MapBuffer));
+                UnmapBuffer = (Delegates.UnmapBuffer)WindowsGetAddress("glUnmapBuffer", typeof(Delegates.UnmapBuffer));
+                GetBufferParameteriv_ = (Delegates.GetBufferParameteriv_)WindowsGetAddress("glGetBufferParameteriv", typeof(Delegates.GetBufferParameteriv_));
+                GetBufferPointerv_ = (Delegates.GetBufferPointerv_)WindowsGetAddress("glGetBufferPointerv", typeof(Delegates.GetBufferPointerv_));
+                BlendEquationSeparate = (Delegates.BlendEquationSeparate)WindowsGetAddress("glBlendEquationSeparate", typeof(Delegates.BlendEquationSeparate));
+                DrawBuffers_ = (Delegates.DrawBuffers_)WindowsGetAddress("glDrawBuffers", typeof(Delegates.DrawBuffers_));
+                StencilOpSeparate = (Delegates.StencilOpSeparate)WindowsGetAddress("glStencilOpSeparate", typeof(Delegates.StencilOpSeparate));
+                StencilFuncSeparate = (Delegates.StencilFuncSeparate)WindowsGetAddress("glStencilFuncSeparate", typeof(Delegates.StencilFuncSeparate));
+                StencilMaskSeparate = (Delegates.StencilMaskSeparate)WindowsGetAddress("glStencilMaskSeparate", typeof(Delegates.StencilMaskSeparate));
+                AttachShader = (Delegates.AttachShader)WindowsGetAddress("glAttachShader", typeof(Delegates.AttachShader));
+                BindAttribLocation = (Delegates.BindAttribLocation)WindowsGetAddress("glBindAttribLocation", typeof(Delegates.BindAttribLocation));
+                CompileShader = (Delegates.CompileShader)WindowsGetAddress("glCompileShader", typeof(Delegates.CompileShader));
+                CreateProgram = (Delegates.CreateProgram)WindowsGetAddress("glCreateProgram", typeof(Delegates.CreateProgram));
+                CreateShader = (Delegates.CreateShader)WindowsGetAddress("glCreateShader", typeof(Delegates.CreateShader));
+                DeleteProgram = (Delegates.DeleteProgram)WindowsGetAddress("glDeleteProgram", typeof(Delegates.DeleteProgram));
+                DeleteShader = (Delegates.DeleteShader)WindowsGetAddress("glDeleteShader", typeof(Delegates.DeleteShader));
+                DetachShader = (Delegates.DetachShader)WindowsGetAddress("glDetachShader", typeof(Delegates.DetachShader));
+                DisableVertexAttribArray = (Delegates.DisableVertexAttribArray)WindowsGetAddress("glDisableVertexAttribArray", typeof(Delegates.DisableVertexAttribArray));
+                EnableVertexAttribArray = (Delegates.EnableVertexAttribArray)WindowsGetAddress("glEnableVertexAttribArray", typeof(Delegates.EnableVertexAttribArray));
+                GetActiveAttrib_ = (Delegates.GetActiveAttrib_)WindowsGetAddress("glGetActiveAttrib", typeof(Delegates.GetActiveAttrib_));
+                GetActiveUniform_ = (Delegates.GetActiveUniform_)WindowsGetAddress("glGetActiveUniform", typeof(Delegates.GetActiveUniform_));
+                GetAttachedShaders_ = (Delegates.GetAttachedShaders_)WindowsGetAddress("glGetAttachedShaders", typeof(Delegates.GetAttachedShaders_));
+                GetAttribLocation = (Delegates.GetAttribLocation)WindowsGetAddress("glGetAttribLocation", typeof(Delegates.GetAttribLocation));
+                GetProgramiv_ = (Delegates.GetProgramiv_)WindowsGetAddress("glGetProgramiv", typeof(Delegates.GetProgramiv_));
+                GetProgramInfoLog_ = (Delegates.GetProgramInfoLog_)WindowsGetAddress("glGetProgramInfoLog", typeof(Delegates.GetProgramInfoLog_));
+                GetShaderiv_ = (Delegates.GetShaderiv_)WindowsGetAddress("glGetShaderiv", typeof(Delegates.GetShaderiv_));
+                GetShaderInfoLog_ = (Delegates.GetShaderInfoLog_)WindowsGetAddress("glGetShaderInfoLog", typeof(Delegates.GetShaderInfoLog_));
+                GetShaderSource_ = (Delegates.GetShaderSource_)WindowsGetAddress("glGetShaderSource", typeof(Delegates.GetShaderSource_));
+                GetUniformLocation = (Delegates.GetUniformLocation)WindowsGetAddress("glGetUniformLocation", typeof(Delegates.GetUniformLocation));
+                GetUniformfv_ = (Delegates.GetUniformfv_)WindowsGetAddress("glGetUniformfv", typeof(Delegates.GetUniformfv_));
+                GetUniformiv_ = (Delegates.GetUniformiv_)WindowsGetAddress("glGetUniformiv", typeof(Delegates.GetUniformiv_));
+                GetVertexAttribdv_ = (Delegates.GetVertexAttribdv_)WindowsGetAddress("glGetVertexAttribdv", typeof(Delegates.GetVertexAttribdv_));
+                GetVertexAttribfv_ = (Delegates.GetVertexAttribfv_)WindowsGetAddress("glGetVertexAttribfv", typeof(Delegates.GetVertexAttribfv_));
+                GetVertexAttribiv_ = (Delegates.GetVertexAttribiv_)WindowsGetAddress("glGetVertexAttribiv", typeof(Delegates.GetVertexAttribiv_));
+                GetVertexAttribPointerv_ = (Delegates.GetVertexAttribPointerv_)WindowsGetAddress("glGetVertexAttribPointerv", typeof(Delegates.GetVertexAttribPointerv_));
+                IsProgram = (Delegates.IsProgram)WindowsGetAddress("glIsProgram", typeof(Delegates.IsProgram));
+                IsShader = (Delegates.IsShader)WindowsGetAddress("glIsShader", typeof(Delegates.IsShader));
+                LinkProgram = (Delegates.LinkProgram)WindowsGetAddress("glLinkProgram", typeof(Delegates.LinkProgram));
+                ShaderSource_ = (Delegates.ShaderSource_)WindowsGetAddress("glShaderSource", typeof(Delegates.ShaderSource_));
+                UseProgram = (Delegates.UseProgram)WindowsGetAddress("glUseProgram", typeof(Delegates.UseProgram));
+                Uniform1f = (Delegates.Uniform1f)WindowsGetAddress("glUniform1f", typeof(Delegates.Uniform1f));
+                Uniform2f = (Delegates.Uniform2f)WindowsGetAddress("glUniform2f", typeof(Delegates.Uniform2f));
+                Uniform3f = (Delegates.Uniform3f)WindowsGetAddress("glUniform3f", typeof(Delegates.Uniform3f));
+                Uniform4f = (Delegates.Uniform4f)WindowsGetAddress("glUniform4f", typeof(Delegates.Uniform4f));
+                Uniform1i = (Delegates.Uniform1i)WindowsGetAddress("glUniform1i", typeof(Delegates.Uniform1i));
+                Uniform2i = (Delegates.Uniform2i)WindowsGetAddress("glUniform2i", typeof(Delegates.Uniform2i));
+                Uniform3i = (Delegates.Uniform3i)WindowsGetAddress("glUniform3i", typeof(Delegates.Uniform3i));
+                Uniform4i = (Delegates.Uniform4i)WindowsGetAddress("glUniform4i", typeof(Delegates.Uniform4i));
+                Uniform1fv_ = (Delegates.Uniform1fv_)WindowsGetAddress("glUniform1fv", typeof(Delegates.Uniform1fv_));
+                Uniform2fv_ = (Delegates.Uniform2fv_)WindowsGetAddress("glUniform2fv", typeof(Delegates.Uniform2fv_));
+                Uniform3fv_ = (Delegates.Uniform3fv_)WindowsGetAddress("glUniform3fv", typeof(Delegates.Uniform3fv_));
+                Uniform4fv_ = (Delegates.Uniform4fv_)WindowsGetAddress("glUniform4fv", typeof(Delegates.Uniform4fv_));
+                Uniform1iv_ = (Delegates.Uniform1iv_)WindowsGetAddress("glUniform1iv", typeof(Delegates.Uniform1iv_));
+                Uniform2iv_ = (Delegates.Uniform2iv_)WindowsGetAddress("glUniform2iv", typeof(Delegates.Uniform2iv_));
+                Uniform3iv_ = (Delegates.Uniform3iv_)WindowsGetAddress("glUniform3iv", typeof(Delegates.Uniform3iv_));
+                Uniform4iv_ = (Delegates.Uniform4iv_)WindowsGetAddress("glUniform4iv", typeof(Delegates.Uniform4iv_));
+                UniformMatrix2fv_ = (Delegates.UniformMatrix2fv_)WindowsGetAddress("glUniformMatrix2fv", typeof(Delegates.UniformMatrix2fv_));
+                UniformMatrix3fv_ = (Delegates.UniformMatrix3fv_)WindowsGetAddress("glUniformMatrix3fv", typeof(Delegates.UniformMatrix3fv_));
+                UniformMatrix4fv_ = (Delegates.UniformMatrix4fv_)WindowsGetAddress("glUniformMatrix4fv", typeof(Delegates.UniformMatrix4fv_));
+                ValidateProgram = (Delegates.ValidateProgram)WindowsGetAddress("glValidateProgram", typeof(Delegates.ValidateProgram));
+                VertexAttrib1d = (Delegates.VertexAttrib1d)WindowsGetAddress("glVertexAttrib1d", typeof(Delegates.VertexAttrib1d));
+                VertexAttrib1dv_ = (Delegates.VertexAttrib1dv_)WindowsGetAddress("glVertexAttrib1dv", typeof(Delegates.VertexAttrib1dv_));
+                VertexAttrib1f = (Delegates.VertexAttrib1f)WindowsGetAddress("glVertexAttrib1f", typeof(Delegates.VertexAttrib1f));
+                VertexAttrib1fv_ = (Delegates.VertexAttrib1fv_)WindowsGetAddress("glVertexAttrib1fv", typeof(Delegates.VertexAttrib1fv_));
+                VertexAttrib1s = (Delegates.VertexAttrib1s)WindowsGetAddress("glVertexAttrib1s", typeof(Delegates.VertexAttrib1s));
+                VertexAttrib1sv_ = (Delegates.VertexAttrib1sv_)WindowsGetAddress("glVertexAttrib1sv", typeof(Delegates.VertexAttrib1sv_));
+                VertexAttrib2d = (Delegates.VertexAttrib2d)WindowsGetAddress("glVertexAttrib2d", typeof(Delegates.VertexAttrib2d));
+                VertexAttrib2dv_ = (Delegates.VertexAttrib2dv_)WindowsGetAddress("glVertexAttrib2dv", typeof(Delegates.VertexAttrib2dv_));
+                VertexAttrib2f = (Delegates.VertexAttrib2f)WindowsGetAddress("glVertexAttrib2f", typeof(Delegates.VertexAttrib2f));
+                VertexAttrib2fv_ = (Delegates.VertexAttrib2fv_)WindowsGetAddress("glVertexAttrib2fv", typeof(Delegates.VertexAttrib2fv_));
+                VertexAttrib2s = (Delegates.VertexAttrib2s)WindowsGetAddress("glVertexAttrib2s", typeof(Delegates.VertexAttrib2s));
+                VertexAttrib2sv_ = (Delegates.VertexAttrib2sv_)WindowsGetAddress("glVertexAttrib2sv", typeof(Delegates.VertexAttrib2sv_));
+                VertexAttrib3d = (Delegates.VertexAttrib3d)WindowsGetAddress("glVertexAttrib3d", typeof(Delegates.VertexAttrib3d));
+                VertexAttrib3dv_ = (Delegates.VertexAttrib3dv_)WindowsGetAddress("glVertexAttrib3dv", typeof(Delegates.VertexAttrib3dv_));
+                VertexAttrib3f = (Delegates.VertexAttrib3f)WindowsGetAddress("glVertexAttrib3f", typeof(Delegates.VertexAttrib3f));
+                VertexAttrib3fv_ = (Delegates.VertexAttrib3fv_)WindowsGetAddress("glVertexAttrib3fv", typeof(Delegates.VertexAttrib3fv_));
+                VertexAttrib3s = (Delegates.VertexAttrib3s)WindowsGetAddress("glVertexAttrib3s", typeof(Delegates.VertexAttrib3s));
+                VertexAttrib3sv_ = (Delegates.VertexAttrib3sv_)WindowsGetAddress("glVertexAttrib3sv", typeof(Delegates.VertexAttrib3sv_));
+                VertexAttrib4Nbv_ = (Delegates.VertexAttrib4Nbv_)WindowsGetAddress("glVertexAttrib4Nbv", typeof(Delegates.VertexAttrib4Nbv_));
+                VertexAttrib4Niv_ = (Delegates.VertexAttrib4Niv_)WindowsGetAddress("glVertexAttrib4Niv", typeof(Delegates.VertexAttrib4Niv_));
+                VertexAttrib4Nsv_ = (Delegates.VertexAttrib4Nsv_)WindowsGetAddress("glVertexAttrib4Nsv", typeof(Delegates.VertexAttrib4Nsv_));
+                VertexAttrib4Nub = (Delegates.VertexAttrib4Nub)WindowsGetAddress("glVertexAttrib4Nub", typeof(Delegates.VertexAttrib4Nub));
+                VertexAttrib4Nubv_ = (Delegates.VertexAttrib4Nubv_)WindowsGetAddress("glVertexAttrib4Nubv", typeof(Delegates.VertexAttrib4Nubv_));
+                VertexAttrib4Nuiv_ = (Delegates.VertexAttrib4Nuiv_)WindowsGetAddress("glVertexAttrib4Nuiv", typeof(Delegates.VertexAttrib4Nuiv_));
+                VertexAttrib4Nusv_ = (Delegates.VertexAttrib4Nusv_)WindowsGetAddress("glVertexAttrib4Nusv", typeof(Delegates.VertexAttrib4Nusv_));
+                VertexAttrib4bv_ = (Delegates.VertexAttrib4bv_)WindowsGetAddress("glVertexAttrib4bv", typeof(Delegates.VertexAttrib4bv_));
+                VertexAttrib4d = (Delegates.VertexAttrib4d)WindowsGetAddress("glVertexAttrib4d", typeof(Delegates.VertexAttrib4d));
+                VertexAttrib4dv_ = (Delegates.VertexAttrib4dv_)WindowsGetAddress("glVertexAttrib4dv", typeof(Delegates.VertexAttrib4dv_));
+                VertexAttrib4f = (Delegates.VertexAttrib4f)WindowsGetAddress("glVertexAttrib4f", typeof(Delegates.VertexAttrib4f));
+                VertexAttrib4fv_ = (Delegates.VertexAttrib4fv_)WindowsGetAddress("glVertexAttrib4fv", typeof(Delegates.VertexAttrib4fv_));
+                VertexAttrib4iv_ = (Delegates.VertexAttrib4iv_)WindowsGetAddress("glVertexAttrib4iv", typeof(Delegates.VertexAttrib4iv_));
+                VertexAttrib4s = (Delegates.VertexAttrib4s)WindowsGetAddress("glVertexAttrib4s", typeof(Delegates.VertexAttrib4s));
+                VertexAttrib4sv_ = (Delegates.VertexAttrib4sv_)WindowsGetAddress("glVertexAttrib4sv", typeof(Delegates.VertexAttrib4sv_));
+                VertexAttrib4ubv_ = (Delegates.VertexAttrib4ubv_)WindowsGetAddress("glVertexAttrib4ubv", typeof(Delegates.VertexAttrib4ubv_));
+                VertexAttrib4uiv_ = (Delegates.VertexAttrib4uiv_)WindowsGetAddress("glVertexAttrib4uiv", typeof(Delegates.VertexAttrib4uiv_));
+                VertexAttrib4usv_ = (Delegates.VertexAttrib4usv_)WindowsGetAddress("glVertexAttrib4usv", typeof(Delegates.VertexAttrib4usv_));
+                VertexAttribPointer_ = (Delegates.VertexAttribPointer_)WindowsGetAddress("glVertexAttribPointer", typeof(Delegates.VertexAttribPointer_));
+                UniformMatrix2x3fv_ = (Delegates.UniformMatrix2x3fv_)WindowsGetAddress("glUniformMatrix2x3fv", typeof(Delegates.UniformMatrix2x3fv_));
+                UniformMatrix3x2fv_ = (Delegates.UniformMatrix3x2fv_)WindowsGetAddress("glUniformMatrix3x2fv", typeof(Delegates.UniformMatrix3x2fv_));
+                UniformMatrix2x4fv_ = (Delegates.UniformMatrix2x4fv_)WindowsGetAddress("glUniformMatrix2x4fv", typeof(Delegates.UniformMatrix2x4fv_));
+                UniformMatrix4x2fv_ = (Delegates.UniformMatrix4x2fv_)WindowsGetAddress("glUniformMatrix4x2fv", typeof(Delegates.UniformMatrix4x2fv_));
+                UniformMatrix3x4fv_ = (Delegates.UniformMatrix3x4fv_)WindowsGetAddress("glUniformMatrix3x4fv", typeof(Delegates.UniformMatrix3x4fv_));
+                UniformMatrix4x3fv_ = (Delegates.UniformMatrix4x3fv_)WindowsGetAddress("glUniformMatrix4x3fv", typeof(Delegates.UniformMatrix4x3fv_));
+                #endregion Windows Vista Core
+            }
+            else if (Environment.OSVersion.Platform == PlatformID.Unix)
+            {
+                #region X11 Core
+                #endregion X11 Core
+            }
+        }
+        #endregion static Constructor
     }
 }
 
diff --git a/Source/OpenGL/OpenGL/Bindings/GLEnums.cs b/Source/OpenGL/OpenGL/Bindings/GLEnums.cs
new file mode 100644
index 00000000..087d7be5
--- /dev/null
+++ b/Source/OpenGL/OpenGL/Bindings/GLEnums.cs
@@ -0,0 +1,5231 @@
+#region License
+//THIS FILE IS AUTOMATICALLY GENERATED
+//DO NOT EDIT BY HAND!!
+//See license.txt for license info
+#endregion
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace OpenTK.OpenGL
+{
+    #region Types
+    using GLsizeiptrARB = System.IntPtr;
+    using GLintptrARB = System.IntPtr;
+    using GLhandleARB = System.Int32;
+    using GLhalfARB = System.Int16;
+    using GLhalfNV = System.Int16;
+    using GLcharARB = System.Char;
+    using GLsizei = System.Int32;
+    using GLsizeiptr = System.IntPtr;
+    using GLintptr = System.IntPtr;
+    using GLenum = System.Int32;
+    using GLboolean = System.Boolean;
+    using GLbitfield = System.Int32;
+    using GLchar = System.Char;
+    using GLbyte = System.Byte;
+    using GLubyte = System.Byte;
+    using GLshort = System.Int16;
+    using GLushort = System.Int16;
+    using GLint = System.Int32;
+    using GLuint = System.Int32;
+    using GLfloat = System.Single;
+    using GLclampf = System.Single;
+    using GLdouble = System.Double;
+    using GLclampd = System.Double;
+    using GLstring = System.String;
+    using GLint64EXT = System.Int64;
+    using GLuint64EXT = System.Int64;
+    using GLint64 = System.Int64;
+    using GLuint64 = System.Int64;
+    #endregion
+
+    #region Enums
+    public struct Enums
+    {
+        public enum PixelStoreParameter : uint
+        {
+            UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS,
+            UNPACK_LSB_FIRST = GetPName.UNPACK_LSB_FIRST,
+            UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX,
+            PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX,
+            UNPACK_ROW_LENGTH = GetPName.UNPACK_ROW_LENGTH,
+            UNPACK_ALIGNMENT = GetPName.UNPACK_ALIGNMENT,
+            UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT,
+            PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX,
+            PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX,
+            PACK_SKIP_ROWS = GetPName.PACK_SKIP_ROWS,
+            PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS,
+            UNPACK_SKIP_ROWS = GetPName.UNPACK_SKIP_ROWS,
+            UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT,
+            UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX,
+            PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX,
+            PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX,
+            PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX,
+            PACK_SKIP_PIXELS = GetPName.PACK_SKIP_PIXELS,
+            PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS,
+            PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX,
+            PACK_SWAP_BYTES = GetPName.PACK_SWAP_BYTES,
+            UNPACK_SWAP_BYTES = GetPName.UNPACK_SWAP_BYTES,
+            PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT,
+            UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS,
+            PACK_LSB_FIRST = GetPName.PACK_LSB_FIRST,
+            PACK_ALIGNMENT = GetPName.PACK_ALIGNMENT,
+            PACK_ROW_LENGTH = GetPName.PACK_ROW_LENGTH,
+            UNPACK_SKIP_PIXELS = GetPName.UNPACK_SKIP_PIXELS,
+            PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX,
+            PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT,
+        }
+
+        public enum HintMode : uint
+        {
+            DONT_CARE = 0x1100,
+            NICEST = 0x1102,
+            FASTEST = 0x1101,
+        }
+
+        public enum ATI_pixel_format_float : uint
+        {
+            COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835,
+            TYPE_RGBA_FLOAT_ATI = 0x8820,
+        }
+
+        public enum INTEL_parallel_arrays : uint
+        {
+            VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5,
+            NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6,
+            COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7,
+            PARALLEL_ARRAYS_INTEL = 0x83F4,
+            TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8,
+        }
+
+        public enum HistogramTargetEXT : uint
+        {
+            HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
+            PROXY_HISTOGRAM_EXT = EXT_histogram.PROXY_HISTOGRAM_EXT,
+        }
+
+        public enum ARB_pixel_buffer_object : uint
+        {
+            PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED,
+            PIXEL_PACK_BUFFER_ARB = 0x88EB,
+            PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF,
+            PIXEL_UNPACK_BUFFER_ARB = 0x88EC,
+        }
+
+        public enum ColorTableTargetSGI : uint
+        {
+            TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
+            POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI,
+            PROXY_TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.PROXY_TEXTURE_COLOR_TABLE_SGI,
+            COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
+            PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI,
+            PROXY_COLOR_TABLE_SGI = SGI_color_table.PROXY_COLOR_TABLE_SGI,
+            PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI,
+            POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
+        }
+
+        public enum SGI_texture_color_table : uint
+        {
+            TEXTURE_COLOR_TABLE_SGI = 0x80BC,
+            PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD,
+        }
+
+        public enum OML_resample : uint
+        {
+            PACK_RESAMPLE_OML = 0x8984,
+            RESAMPLE_AVERAGE_OML = 0x8988,
+            RESAMPLE_REPLICATE_OML = 0x8986,
+            RESAMPLE_DECIMATE_OML = 0x8989,
+            UNPACK_RESAMPLE_OML = 0x8985,
+            RESAMPLE_ZERO_FILL_OML = 0x8987,
+        }
+
+        public enum WIN_phong_shading : uint
+        {
+            PHONG_WIN = 0x80EA,
+            PHONG_HINT_WIN = 0x80EB,
+        }
+
+        public enum SGIX_sprite : uint
+        {
+            SPRITE_SGIX = 0x8148,
+            SPRITE_MODE_SGIX = 0x8149,
+            SPRITE_TRANSLATION_SGIX = 0x814B,
+            SPRITE_AXIS_SGIX = 0x814A,
+            SPRITE_AXIAL_SGIX = 0x814C,
+            SPRITE_OBJECT_ALIGNED_SGIX = 0x814D,
+            SPRITE_EYE_ALIGNED_SGIX = 0x814E,
+        }
+
+        public enum EXT_pixel_transform_color_table : uint
+        {
+        }
+
+        public enum SGIX_async_pixel : uint
+        {
+            ASYNC_TEX_IMAGE_SGIX = 0x835C,
+            MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F,
+            ASYNC_DRAW_PIXELS_SGIX = 0x835D,
+            ASYNC_READ_PIXELS_SGIX = 0x835E,
+            MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360,
+            MAX_ASYNC_READ_PIXELS_SGIX = 0x8361,
+        }
+
+        public enum ARB_texture_env_add : uint
+        {
+        }
+
+        public enum BeginMode : uint
+        {
+            QUAD_STRIP = 0x0008,
+            POLYGON = 0x0009,
+            LINES = 0x0001,
+            TRIANGLES = 0x0004,
+            TRIANGLE_STRIP = 0x0005,
+            LINE_LOOP = 0x0002,
+            LINE_STRIP = 0x0003,
+            QUADS = 0x0007,
+            TRIANGLE_FAN = 0x0006,
+            POINTS = 0x0000,
+        }
+
+        public enum ListMode : uint
+        {
+            COMPILE = 0x1300,
+            COMPILE_AND_EXECUTE = 0x1301,
+        }
+
+        public enum GetMapQuery : uint
+        {
+            ORDER = 0x0A01,
+            DOMAIN = 0x0A02,
+            COEFF = 0x0A00,
+        }
+
+        public enum ARB_matrix_palette : uint
+        {
+            MAX_PALETTE_MATRICES_ARB = 0x8842,
+            CURRENT_MATRIX_INDEX_ARB = 0x8845,
+            MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849,
+            MATRIX_INDEX_ARRAY_ARB = 0x8844,
+            MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846,
+            CURRENT_PALETTE_MATRIX_ARB = 0x8843,
+            MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841,
+            MATRIX_PALETTE_ARB = 0x8840,
+            MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848,
+            MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847,
+        }
+
+        public enum TextureParameterName : uint
+        {
+            TEXTURE_BORDER_COLOR = GetTextureParameter.TEXTURE_BORDER_COLOR,
+            TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX,
+            TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX,
+            POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX,
+            TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX,
+            GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS,
+            TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX,
+            TEXTURE_COMPARE_OPERATOR_SGIX = SGIX_shadow.TEXTURE_COMPARE_OPERATOR_SGIX,
+            QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS,
+            TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX,
+            TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX,
+            TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX,
+            TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX,
+            TEXTURE_MAG_FILTER = 0x2800,
+            SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX,
+            TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS,
+            DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS,
+            TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX,
+            DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS,
+            TEXTURE_WRAP_S = 0x2802,
+            TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX,
+            POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX,
+            DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS,
+            TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT,
+            TEXTURE_MIN_FILTER = 0x2801,
+            TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX,
+            TEXTURE_WRAP_T = 0x2803,
+            TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX,
+            TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX,
+            TEXTURE_PRIORITY = GetTextureParameter.TEXTURE_PRIORITY,
+        }
+
+        public enum SGI_depth_pass_instrument : uint
+        {
+            DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311,
+            DEPTH_PASS_INSTRUMENT_SGIX = 0x8310,
+            DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312,
+        }
+
+        public enum FrontFaceDirection : uint
+        {
+            CCW = 0x0901,
+            CW = 0x0900,
+        }
+
+        public enum NV_point_sprite : uint
+        {
+            COORD_REPLACE_NV = 0x8862,
+            POINT_SPRITE_R_MODE_NV = 0x8863,
+            POINT_SPRITE_NV = 0x8861,
+        }
+
+        public enum INGR_palette_buffer : uint
+        {
+        }
+
+        public enum PolygonMode : uint
+        {
+            FILL = 0x1B02,
+            LINE = 0x1B01,
+            POINT = 0x1B00,
+        }
+
+        public enum NV_fog_distance : uint
+        {
+            EYE_PLANE = TextureGenParameter.EYE_PLANE,
+            FOG_DISTANCE_MODE_NV = 0x855A,
+            EYE_RADIAL_NV = 0x855B,
+            EYE_PLANE_ABSOLUTE_NV = 0x855C,
+        }
+
+        public enum MaterialFace : uint
+        {
+            BACK = DrawBufferMode.BACK,
+            FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
+            FRONT = DrawBufferMode.FRONT,
+        }
+
+        public enum BlendingFactorDest : uint
+        {
+            ZERO = 0,
+            ONE_MINUS_SRC_ALPHA = 0x0303,
+            ONE_MINUS_DST_ALPHA = 0x0305,
+            CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT,
+            DST_ALPHA = 0x0304,
+            CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT,
+            ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT,
+            ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT,
+            SRC_ALPHA = 0x0302,
+            SRC_COLOR = 0x0300,
+            ONE_MINUS_SRC_COLOR = 0x0301,
+            ONE = 1,
+        }
+
+        public enum MatrixMode : uint
+        {
+            PROJECTION = 0x1701,
+            MODELVIEW = 0x1700,
+            TEXTURE = 0x1702,
+        }
+
+        public enum TextureMagFilter : uint
+        {
+            LINEAR = 0x2601,
+            PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX,
+            FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
+            LINEAR_SHARPEN_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_SGIS,
+            PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX,
+            LINEAR_DETAIL_SGIS = SGIS_detail_texture.LINEAR_DETAIL_SGIS,
+            PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX,
+            NEAREST = 0x2600,
+            LINEAR_SHARPEN_COLOR_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_COLOR_SGIS,
+            LINEAR_SHARPEN_ALPHA_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_ALPHA_SGIS,
+            LINEAR_DETAIL_ALPHA_SGIS = SGIS_detail_texture.LINEAR_DETAIL_ALPHA_SGIS,
+            LINEAR_DETAIL_COLOR_SGIS = SGIS_detail_texture.LINEAR_DETAIL_COLOR_SGIS,
+        }
+
+        public enum NV_evaluators : uint
+        {
+            EVAL_VERTEX_ATTRIB4_NV = 0x86CA,
+            EVAL_VERTEX_ATTRIB5_NV = 0x86CB,
+            EVAL_VERTEX_ATTRIB15_NV = 0x86D5,
+            MAX_MAP_TESSELLATION_NV = 0x86D6,
+            EVAL_VERTEX_ATTRIB3_NV = 0x86C9,
+            EVAL_VERTEX_ATTRIB12_NV = 0x86D2,
+            EVAL_VERTEX_ATTRIB14_NV = 0x86D4,
+            EVAL_VERTEX_ATTRIB13_NV = 0x86D3,
+            MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7,
+            MAP_TESSELLATION_NV = 0x86C2,
+            MAP_ATTRIB_U_ORDER_NV = 0x86C3,
+            EVAL_VERTEX_ATTRIB8_NV = 0x86CE,
+            EVAL_VERTEX_ATTRIB11_NV = 0x86D1,
+            EVAL_VERTEX_ATTRIB9_NV = 0x86CF,
+            EVAL_VERTEX_ATTRIB7_NV = 0x86CD,
+            EVAL_VERTEX_ATTRIB10_NV = 0x86D0,
+            EVAL_VERTEX_ATTRIB2_NV = 0x86C8,
+            EVAL_VERTEX_ATTRIB0_NV = 0x86C6,
+            EVAL_2D_NV = 0x86C0,
+            EVAL_VERTEX_ATTRIB1_NV = 0x86C7,
+            MAP_ATTRIB_V_ORDER_NV = 0x86C4,
+            EVAL_TRIANGULAR_2D_NV = 0x86C1,
+            EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5,
+            EVAL_VERTEX_ATTRIB6_NV = 0x86CC,
+        }
+
+        public enum GetHistogramParameterPNameEXT : uint
+        {
+            HISTOGRAM_BLUE_SIZE_EXT = EXT_histogram.HISTOGRAM_BLUE_SIZE_EXT,
+            HISTOGRAM_FORMAT_EXT = EXT_histogram.HISTOGRAM_FORMAT_EXT,
+            HISTOGRAM_GREEN_SIZE_EXT = EXT_histogram.HISTOGRAM_GREEN_SIZE_EXT,
+            HISTOGRAM_ALPHA_SIZE_EXT = EXT_histogram.HISTOGRAM_ALPHA_SIZE_EXT,
+            HISTOGRAM_LUMINANCE_SIZE_EXT = EXT_histogram.HISTOGRAM_LUMINANCE_SIZE_EXT,
+            HISTOGRAM_RED_SIZE_EXT = EXT_histogram.HISTOGRAM_RED_SIZE_EXT,
+            HISTOGRAM_SINK_EXT = EXT_histogram.HISTOGRAM_SINK_EXT,
+            HISTOGRAM_WIDTH_EXT = EXT_histogram.HISTOGRAM_WIDTH_EXT,
+        }
+
+        public enum CullFaceMode : uint
+        {
+            BACK = DrawBufferMode.BACK,
+            FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
+            FRONT = DrawBufferMode.FRONT,
+        }
+
+        public enum ARB_color_buffer_float : uint
+        {
+            CLAMP_READ_COLOR_ARB = 0x891C,
+            CLAMP_FRAGMENT_COLOR_ARB = 0x891B,
+            FIXED_ONLY_ARB = 0x891D,
+            CLAMP_VERTEX_COLOR_ARB = 0x891A,
+            RGBA_FLOAT_MODE_ARB = 0x8820,
+        }
+
+        public enum ConvolutionBorderModeEXT : uint
+        {
+            REDUCE_EXT = EXT_convolution.REDUCE_EXT,
+        }
+
+        public enum SGIX_blend_alpha_minmax : uint
+        {
+            ALPHA_MAX_SGIX = 0x8321,
+            ASYNC_MARKER_SGIX = 0x8329,
+            ALPHA_MIN_SGIX = 0x8320,
+        }
+
+        public enum MinmaxTargetEXT : uint
+        {
+            MINMAX_EXT = EXT_histogram.MINMAX_EXT,
+        }
+
+        public enum FfdMaskSGIX : uint
+        {
+            GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002,
+            TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001,
+        }
+
+        public enum TextureEnvParameter : uint
+        {
+            TEXTURE_ENV_COLOR = 0x2201,
+            TEXTURE_ENV_MODE = 0x2200,
+        }
+
+        public enum ARB_shading_language_100 : uint
+        {
+            SHADING_LANGUAGE_VERSION_ARB = 0x8B8C,
+        }
+
+        public enum _3DFX_multisample : uint
+        {
+            SAMPLE_BUFFERS_3DFX = 0x86B3,
+            MULTISAMPLE_BIT_3DFX = 0x20000000,
+            MULTISAMPLE_3DFX = 0x86B2,
+            SAMPLES_3DFX = 0x86B4,
+        }
+
+        public enum DrawBufferMode : uint
+        {
+            FRONT_RIGHT = 0x0401,
+            AUX3 = 0x040C,
+            AUX1 = 0x040A,
+            FRONT_AND_BACK = 0x0408,
+            LEFT = 0x0406,
+            NONE = 0,
+            RIGHT = 0x0407,
+            BACK_RIGHT = 0x0403,
+            AUX2 = 0x040B,
+            AUX0 = 0x0409,
+            FRONT_LEFT = 0x0400,
+            BACK = 0x0405,
+            FRONT = 0x0404,
+            BACK_LEFT = 0x0402,
+        }
+
+        public enum ShadingModel : uint
+        {
+            SMOOTH = 0x1D01,
+            FLAT = 0x1D00,
+        }
+
+        public enum EXT_coordinate_frame : uint
+        {
+            BINORMAL_ARRAY_STRIDE_EXT = 0x8441,
+            BINORMAL_ARRAY_TYPE_EXT = 0x8440,
+            MAP1_TANGENT_EXT = 0x8444,
+            TANGENT_ARRAY_POINTER_EXT = 0x8442,
+            CURRENT_TANGENT_EXT = 0x843B,
+            MAP1_BINORMAL_EXT = 0x8446,
+            TANGENT_ARRAY_TYPE_EXT = 0x843E,
+            CURRENT_BINORMAL_EXT = 0x843C,
+            MAP2_TANGENT_EXT = 0x8445,
+            MAP2_BINORMAL_EXT = 0x8447,
+            BINORMAL_ARRAY_EXT = 0x843A,
+            TANGENT_ARRAY_STRIDE_EXT = 0x843F,
+            TANGENT_ARRAY_EXT = 0x8439,
+            BINORMAL_ARRAY_POINTER_EXT = 0x8443,
+        }
+
+        public enum EXT_texture3D : uint
+        {
+            TEXTURE_WRAP_R = 0x8072,
+            UNPACK_IMAGE_HEIGHT_EXT = 0x806E,
+            PROXY_TEXTURE_3D = 0x8070,
+            UNPACK_SKIP_IMAGES_EXT = 0x806D,
+            MAX_3D_TEXTURE_SIZE = 0x8073,
+            TEXTURE_3D_EXT = 0x806F,
+            PACK_SKIP_IMAGES = 0x806B,
+            PACK_IMAGE_HEIGHT = 0x806C,
+            PROXY_TEXTURE_3D_EXT = 0x8070,
+            MAX_3D_TEXTURE_SIZE_EXT = 0x8073,
+            TEXTURE_DEPTH_EXT = 0x8071,
+            TEXTURE_DEPTH = 0x8071,
+            PACK_SKIP_IMAGES_EXT = 0x806B,
+            TEXTURE_WRAP_R_EXT = 0x8072,
+            UNPACK_SKIP_IMAGES = 0x806D,
+            UNPACK_IMAGE_HEIGHT = 0x806E,
+            TEXTURE_3D = 0x806F,
+            PACK_IMAGE_HEIGHT_EXT = 0x806C,
+        }
+
+        public enum ColorMaterialParameter : uint
+        {
+            EMISSION = MaterialParameter.EMISSION,
+            DIFFUSE = LightParameter.DIFFUSE,
+            AMBIENT_AND_DIFFUSE = MaterialParameter.AMBIENT_AND_DIFFUSE,
+            SPECULAR = LightParameter.SPECULAR,
+            AMBIENT = LightParameter.AMBIENT,
+        }
+
+        public enum TextureWrapMode : uint
+        {
+            CLAMP_TO_BORDER_SGIS = SGIS_texture_border_clamp.CLAMP_TO_BORDER_SGIS,
+            CLAMP = 0x2900,
+            REPEAT = 0x2901,
+            CLAMP_TO_EDGE_SGIS = SGIS_texture_edge_clamp.CLAMP_TO_EDGE_SGIS,
+        }
+
+        public enum SGIX_interlace : uint
+        {
+            INTERLACE_SGIX = 0x8094,
+        }
+
+        public enum EXT_vertex_array : uint
+        {
+            TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092,
+            NORMAL_ARRAY_COUNT_EXT = 0x8080,
+            INDEX_ARRAY_TYPE_EXT = 0x8085,
+            VERTEX_ARRAY_TYPE_EXT = 0x807B,
+            INDEX_ARRAY_COUNT_EXT = 0x8087,
+            TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
+            COLOR_ARRAY_POINTER_EXT = 0x8090,
+            INDEX_ARRAY_POINTER_EXT = 0x8091,
+            COLOR_ARRAY_TYPE_EXT = 0x8082,
+            NORMAL_ARRAY_POINTER_EXT = 0x808F,
+            TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B,
+            VERTEX_ARRAY_SIZE_EXT = 0x807A,
+            VERTEX_ARRAY_STRIDE_EXT = 0x807C,
+            VERTEX_ARRAY_POINTER_EXT = 0x808E,
+            INDEX_ARRAY_STRIDE_EXT = 0x8086,
+            VERTEX_ARRAY_COUNT_EXT = 0x807D,
+            EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093,
+            TEXTURE_COORD_ARRAY_EXT = 0x8078,
+            VERTEX_ARRAY_EXT = 0x8074,
+            TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A,
+            COLOR_ARRAY_EXT = 0x8076,
+            COLOR_ARRAY_SIZE_EXT = 0x8081,
+            TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
+            NORMAL_ARRAY_TYPE_EXT = 0x807E,
+            NORMAL_ARRAY_STRIDE_EXT = 0x807F,
+            COLOR_ARRAY_COUNT_EXT = 0x8084,
+            EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C,
+            EDGE_FLAG_ARRAY_EXT = 0x8079,
+            INDEX_ARRAY_EXT = 0x8077,
+            NORMAL_ARRAY_EXT = 0x8075,
+            EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D,
+            COLOR_ARRAY_STRIDE_EXT = 0x8083,
+        }
+
+        public enum NV_texture_env_combine4 : uint
+        {
+            COMBINE4_NV = 0x8503,
+            SOURCE3_RGB_NV = 0x8583,
+            SOURCE3_ALPHA_NV = 0x858B,
+            OPERAND3_RGB_NV = 0x8593,
+            OPERAND3_ALPHA_NV = 0x859B,
+        }
+
+        public enum PixelCopyType : uint
+        {
+            DEPTH = 0x1801,
+            COLOR = 0x1800,
+            STENCIL = 0x1802,
+        }
+
+        public enum LightParameter : uint
+        {
+            POSITION = 0x1203,
+            SPOT_DIRECTION = 0x1204,
+            LINEAR_ATTENUATION = 0x1208,
+            SPOT_CUTOFF = 0x1206,
+            SPOT_EXPONENT = 0x1205,
+            CONSTANT_ATTENUATION = 0x1207,
+            QUADRATIC_ATTENUATION = 0x1209,
+            SPECULAR = 0x1202,
+            DIFFUSE = 0x1201,
+            AMBIENT = 0x1200,
+        }
+
+        public enum GetMinmaxParameterPNameEXT : uint
+        {
+            MINMAX_SINK_EXT = EXT_histogram.MINMAX_SINK_EXT,
+            MINMAX_FORMAT_EXT = EXT_histogram.MINMAX_FORMAT_EXT,
+        }
+
+        public enum ARB_imaging : uint
+        {
+            CONVOLUTION_WIDTH = 0x8018,
+            COLOR_MATRIX_STACK_DEPTH = 0x80B2,
+            BLEND_EQUATION = 0x8009,
+            COLOR_TABLE_BIAS = 0x80D7,
+            CONSTANT_BORDER = 0x8151,
+            HISTOGRAM = 0x8024,
+            COLOR_TABLE_GREEN_SIZE = 0x80DB,
+            HISTOGRAM_RED_SIZE = 0x8028,
+            CONSTANT_ALPHA = 0x8003,
+            TABLE_TOO_LARGE = 0x8031,
+            POST_CONVOLUTION_GREEN_SCALE = 0x801D,
+            MINMAX_SINK = 0x8030,
+            PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
+            COLOR_TABLE_SCALE = 0x80D6,
+            COLOR_MATRIX = 0x80B1,
+            CONVOLUTION_FILTER_SCALE = 0x8014,
+            BLEND_COLOR = 0x8005,
+            MIN = 0x8007,
+            HISTOGRAM_SINK = 0x802D,
+            POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5,
+            SEPARABLE_2D = 0x8012,
+            FUNC_REVERSE_SUBTRACT = 0x800B,
+            CONVOLUTION_FORMAT = 0x8017,
+            REPLICATE_BORDER = 0x8153,
+            CONSTANT_COLOR = 0x8001,
+            COLOR_TABLE = 0x80D0,
+            POST_CONVOLUTION_BLUE_SCALE = 0x801E,
+            FUNC_ADD = 0x8006,
+            CONVOLUTION_2D = 0x8011,
+            POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB,
+            POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7,
+            MINMAX = 0x802E,
+            POST_CONVOLUTION_ALPHA_BIAS = 0x8023,
+            POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6,
+            POST_COLOR_MATRIX_RED_BIAS = 0x80B8,
+            HISTOGRAM_BLUE_SIZE = 0x802A,
+            POST_CONVOLUTION_BLUE_BIAS = 0x8022,
+            COLOR_TABLE_FORMAT = 0x80D8,
+            POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2,
+            CONVOLUTION_HEIGHT = 0x8019,
+            POST_CONVOLUTION_COLOR_TABLE = 0x80D1,
+            MINMAX_FORMAT = 0x802F,
+            COLOR_TABLE_ALPHA_SIZE = 0x80DD,
+            POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA,
+            PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
+            PROXY_COLOR_TABLE = 0x80D3,
+            HISTOGRAM_ALPHA_SIZE = 0x802B,
+            MAX_CONVOLUTION_WIDTH = 0x801A,
+            POST_COLOR_MATRIX_RED_SCALE = 0x80B4,
+            POST_CONVOLUTION_ALPHA_SCALE = 0x801F,
+            CONVOLUTION_BORDER_COLOR = 0x8154,
+            COLOR_TABLE_BLUE_SIZE = 0x80DC,
+            ONE_MINUS_CONSTANT_COLOR = 0x8002,
+            COLOR_TABLE_LUMINANCE_SIZE = 0x80DE,
+            POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9,
+            ONE_MINUS_CONSTANT_ALPHA = 0x8004,
+            FUNC_SUBTRACT = 0x800A,
+            COLOR_TABLE_INTENSITY_SIZE = 0x80DF,
+            REDUCE = 0x8016,
+            COLOR_TABLE_RED_SIZE = 0x80DA,
+            CONVOLUTION_BORDER_MODE = 0x8013,
+            HISTOGRAM_GREEN_SIZE = 0x8029,
+            POST_CONVOLUTION_GREEN_BIAS = 0x8021,
+            HISTOGRAM_FORMAT = 0x8027,
+            CONVOLUTION_1D = 0x8010,
+            POST_CONVOLUTION_RED_BIAS = 0x8020,
+            MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3,
+            COLOR_TABLE_WIDTH = 0x80D9,
+            POST_CONVOLUTION_RED_SCALE = 0x801C,
+            MAX = 0x8008,
+            PROXY_HISTOGRAM = 0x8025,
+            MAX_CONVOLUTION_HEIGHT = 0x801B,
+            CONVOLUTION_FILTER_BIAS = 0x8015,
+            HISTOGRAM_WIDTH = 0x8026,
+            HISTOGRAM_LUMINANCE_SIZE = 0x802C,
+        }
+
+        public enum NV_vertex_program2_option : uint
+        {
+            MAX_PROGRAM_CALL_DEPTH_NV = NV_fragment_program2.MAX_PROGRAM_CALL_DEPTH_NV,
+            MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = NV_fragment_program2.MAX_PROGRAM_EXEC_INSTRUCTIONS_NV,
+        }
+
+        public enum NV_primitive_restart : uint
+        {
+            PRIMITIVE_RESTART_NV = 0x8558,
+            PRIMITIVE_RESTART_INDEX_NV = 0x8559,
+        }
+
+        public enum NV_vertex_program : uint
+        {
+            VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643,
+            MAP1_VERTEX_ATTRIB12_4_NV = 0x866C,
+            ATTRIB_ARRAY_SIZE_NV = 0x8623,
+            MATRIX7_NV = 0x8637,
+            MAP2_VERTEX_ATTRIB14_4_NV = 0x867E,
+            VERTEX_ATTRIB_ARRAY2_NV = 0x8652,
+            MAP2_VERTEX_ATTRIB15_4_NV = 0x867F,
+            VERTEX_ATTRIB_ARRAY9_NV = 0x8659,
+            MAP2_VERTEX_ATTRIB12_4_NV = 0x867C,
+            MAP2_VERTEX_ATTRIB3_4_NV = 0x8673,
+            VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642,
+            MODELVIEW_PROJECTION_NV = 0x8629,
+            MAP2_VERTEX_ATTRIB2_4_NV = 0x8672,
+            MAP2_VERTEX_ATTRIB11_4_NV = 0x867B,
+            VERTEX_ATTRIB_ARRAY8_NV = 0x8658,
+            CURRENT_MATRIX_NV = 0x8641,
+            VERTEX_PROGRAM_BINDING_NV = 0x864A,
+            VERTEX_ATTRIB_ARRAY0_NV = 0x8650,
+            MAP2_VERTEX_ATTRIB1_4_NV = 0x8671,
+            VERTEX_ATTRIB_ARRAY7_NV = 0x8657,
+            PROGRAM_PARAMETER_NV = 0x8644,
+            VERTEX_PROGRAM_NV = 0x8620,
+            ATTRIB_ARRAY_POINTER_NV = 0x8645,
+            PROGRAM_STRING_NV = 0x8628,
+            MAP2_VERTEX_ATTRIB0_4_NV = 0x8670,
+            VERTEX_ATTRIB_ARRAY4_NV = 0x8654,
+            MAP1_VERTEX_ATTRIB7_4_NV = 0x8667,
+            PROGRAM_TARGET_NV = 0x8646,
+            MAP1_VERTEX_ATTRIB11_4_NV = 0x866B,
+            MAP2_VERTEX_ATTRIB7_4_NV = 0x8677,
+            VERTEX_ATTRIB_ARRAY6_NV = 0x8656,
+            MAP1_VERTEX_ATTRIB8_4_NV = 0x8668,
+            VERTEX_ATTRIB_ARRAY5_NV = 0x8655,
+            VERTEX_STATE_PROGRAM_NV = 0x8621,
+            MAP1_VERTEX_ATTRIB9_4_NV = 0x8669,
+            IDENTITY_NV = 0x862A,
+            MAP2_VERTEX_ATTRIB6_4_NV = 0x8676,
+            MATRIX4_NV = 0x8634,
+            PROGRAM_RESIDENT_NV = 0x8647,
+            MAP1_VERTEX_ATTRIB5_4_NV = 0x8665,
+            MAP2_VERTEX_ATTRIB4_4_NV = 0x8674,
+            MAP1_VERTEX_ATTRIB6_4_NV = 0x8666,
+            MAP1_VERTEX_ATTRIB13_4_NV = 0x866D,
+            MAP2_VERTEX_ATTRIB5_4_NV = 0x8675,
+            MAP1_VERTEX_ATTRIB10_4_NV = 0x866A,
+            MAP1_VERTEX_ATTRIB1_4_NV = 0x8661,
+            MAP2_VERTEX_ATTRIB13_4_NV = 0x867D,
+            VERTEX_ATTRIB_ARRAY3_NV = 0x8653,
+            ATTRIB_ARRAY_TYPE_NV = 0x8625,
+            MAP1_VERTEX_ATTRIB14_4_NV = 0x866E,
+            MAP1_VERTEX_ATTRIB2_4_NV = 0x8662,
+            TRACK_MATRIX_TRANSFORM_NV = 0x8649,
+            MATRIX0_NV = 0x8630,
+            MAP1_VERTEX_ATTRIB3_4_NV = 0x8663,
+            MAP2_VERTEX_ATTRIB10_4_NV = 0x867A,
+            INVERSE_NV = 0x862B,
+            VERTEX_ATTRIB_ARRAY14_NV = 0x865E,
+            VERTEX_ATTRIB_ARRAY15_NV = 0x865F,
+            VERTEX_ATTRIB_ARRAY12_NV = 0x865C,
+            MAX_TRACK_MATRICES_NV = 0x862F,
+            MAP1_VERTEX_ATTRIB4_4_NV = 0x8664,
+            VERTEX_ATTRIB_ARRAY11_NV = 0x865B,
+            VERTEX_ATTRIB_ARRAY13_NV = 0x865D,
+            VERTEX_ATTRIB_ARRAY10_NV = 0x865A,
+            MATRIX6_NV = 0x8636,
+            PROGRAM_LENGTH_NV = 0x8627,
+            MAP1_VERTEX_ATTRIB0_4_NV = 0x8660,
+            VERTEX_ATTRIB_ARRAY1_NV = 0x8651,
+            MAP1_VERTEX_ATTRIB15_4_NV = 0x866F,
+            MAP2_VERTEX_ATTRIB9_4_NV = 0x8679,
+            INVERSE_TRANSPOSE_NV = 0x862D,
+            PROGRAM_ERROR_POSITION_NV = 0x864B,
+            TRACK_MATRIX_NV = 0x8648,
+            MAP2_VERTEX_ATTRIB8_4_NV = 0x8678,
+            CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640,
+            MATRIX1_NV = 0x8631,
+            ATTRIB_ARRAY_STRIDE_NV = 0x8624,
+            MATRIX3_NV = 0x8633,
+            MATRIX5_NV = 0x8635,
+            TRANSPOSE_NV = 0x862C,
+            MATRIX2_NV = 0x8632,
+            CURRENT_ATTRIB_NV = 0x8626,
+            MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E,
+        }
+
+        public enum ARB_shadow_ambient : uint
+        {
+            TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF,
+        }
+
+        public enum FragmentLightModelParameterSGIX : uint
+        {
+            FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX,
+            FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX,
+            FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX,
+            FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX,
+        }
+
+        public enum StringName : uint
+        {
+            EXTENSIONS = 0x1F03,
+            VERSION = 0x1F02,
+            RENDERER = 0x1F01,
+            VENDOR = 0x1F00,
+        }
+
+        public enum MESA_pack_invert : uint
+        {
+            PACK_INVERT_MESA = 0x8758,
+        }
+
+        public enum NV_texgen_reflection : uint
+        {
+            NORMAL_MAP_NV = 0x8511,
+            REFLECTION_MAP_NV = 0x8512,
+        }
+
+        public enum FfdTargetSGIX : uint
+        {
+            GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX,
+            TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX,
+        }
+
+        public enum EXT_framebuffer_blit : uint
+        {
+            DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CAA,
+            READ_FRAMEBUFFER_BINDING_EXT = EXT_framebuffer_object.FRAMEBUFFER_BINDING_EXT,
+            READ_FRAMEBUFFER_EXT = 0x8CA8,
+            DRAW_FRAMEBUFFER_EXT = 0x8CA9,
+        }
+
+        public enum EnableCap : uint
+        {
+            MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3,
+            MAP2_NORMAL = GetPName.MAP2_NORMAL,
+            FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX,
+            CLIP_PLANE4 = GetPName.CLIP_PLANE4,
+            ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX,
+            FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX,
+            HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
+            LIGHT3 = GetPName.LIGHT3,
+            POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI,
+            CLIP_PLANE3 = GetPName.CLIP_PLANE3,
+            TEXTURE_COORD_ARRAY = GetPName.TEXTURE_COORD_ARRAY,
+            FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX,
+            CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
+            ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX,
+            LIGHT4 = GetPName.LIGHT4,
+            MAP2_INDEX = GetPName.MAP2_INDEX,
+            MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1,
+            POLYGON_OFFSET_POINT = GetPName.POLYGON_OFFSET_POINT,
+            ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX,
+            TEXTURE_1D = GetPName.TEXTURE_1D,
+            CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
+            TEXTURE_2D = GetPName.TEXTURE_2D,
+            MAP1_COLOR_4 = GetPName.MAP1_COLOR_4,
+            INDEX_LOGIC_OP = GetPName.INDEX_LOGIC_OP,
+            RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT,
+            FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX,
+            SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS,
+            LINE_STIPPLE = GetPName.LINE_STIPPLE,
+            POLYGON_OFFSET_FILL = GetPName.POLYGON_OFFSET_FILL,
+            LIGHT0 = GetPName.LIGHT0,
+            FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX,
+            CLIP_PLANE2 = GetPName.CLIP_PLANE2,
+            LIGHT5 = GetPName.LIGHT5,
+            FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX,
+            REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX,
+            SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS,
+            CLIP_PLANE1 = GetPName.CLIP_PLANE1,
+            COLOR_LOGIC_OP = GetPName.COLOR_LOGIC_OP,
+            FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX,
+            ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX,
+            MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4,
+            MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2,
+            NORMAL_ARRAY = GetPName.NORMAL_ARRAY,
+            FOG = GetPName.FOG,
+            CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX,
+            POINT_SMOOTH = GetPName.POINT_SMOOTH,
+            SCISSOR_TEST = GetPName.SCISSOR_TEST,
+            INDEX_ARRAY = GetPName.INDEX_ARRAY,
+            TEXTURE_GEN_S = GetPName.TEXTURE_GEN_S,
+            TEXTURE_GEN_R = GetPName.TEXTURE_GEN_R,
+            TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
+            NORMALIZE = GetPName.NORMALIZE,
+            CULL_FACE = GetPName.CULL_FACE,
+            LIGHT1 = GetPName.LIGHT1,
+            MAP1_NORMAL = GetPName.MAP1_NORMAL,
+            DEPTH_TEST = GetPName.DEPTH_TEST,
+            FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX,
+            MINMAX_EXT = EXT_histogram.MINMAX_EXT,
+            POLYGON_OFFSET_LINE = GetPName.POLYGON_OFFSET_LINE,
+            COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
+            MAP1_INDEX = GetPName.MAP1_INDEX,
+            AUTO_NORMAL = GetPName.AUTO_NORMAL,
+            POLYGON_SMOOTH = GetPName.POLYGON_SMOOTH,
+            POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
+            PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX,
+            CLIP_PLANE0 = GetPName.CLIP_PLANE0,
+            SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT,
+            POLYGON_STIPPLE = GetPName.POLYGON_STIPPLE,
+            SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS,
+            MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3,
+            MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3,
+            IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX,
+            TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
+            FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX,
+            PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS,
+            LIGHT6 = GetPName.LIGHT6,
+            ALPHA_TEST = GetPName.ALPHA_TEST,
+            STENCIL_TEST = GetPName.STENCIL_TEST,
+            BLEND = GetPName.BLEND,
+            MAP2_COLOR_4 = GetPName.MAP2_COLOR_4,
+            FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX,
+            FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
+            LIGHTING = GetPName.LIGHTING,
+            TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
+            CLIP_PLANE5 = GetPName.CLIP_PLANE5,
+            LINE_SMOOTH = GetPName.LINE_SMOOTH,
+            SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
+            DITHER = GetPName.DITHER,
+            INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX,
+            LIGHT2 = GetPName.LIGHT2,
+            TEXTURE_GEN_Q = GetPName.TEXTURE_GEN_Q,
+            EDGE_FLAG_ARRAY = GetPName.EDGE_FLAG_ARRAY,
+            COLOR_ARRAY = GetPName.COLOR_ARRAY,
+            TEXTURE_GEN_T = GetPName.TEXTURE_GEN_T,
+            MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4,
+            MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2,
+            MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4,
+            LIGHT7 = GetPName.LIGHT7,
+            SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX,
+            FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX,
+            MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3,
+            MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1,
+            MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4,
+            MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS,
+            VERTEX_ARRAY = GetPName.VERTEX_ARRAY,
+            COLOR_MATERIAL = GetPName.COLOR_MATERIAL,
+        }
+
+        public enum EXT_bgra : uint
+        {
+            BGRA = 0x80E1,
+            BGR_EXT = 0x80E0,
+            BGRA_EXT = 0x80E1,
+            BGR = 0x80E0,
+        }
+
+        public enum SGIS_point_line_texgen : uint
+        {
+            EYE_DISTANCE_TO_LINE_SGIS = 0x81F2,
+            EYE_LINE_SGIS = 0x81F6,
+            OBJECT_LINE_SGIS = 0x81F7,
+            OBJECT_POINT_SGIS = 0x81F5,
+            OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1,
+            EYE_POINT_SGIS = 0x81F4,
+            OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3,
+            EYE_DISTANCE_TO_POINT_SGIS = 0x81F0,
+        }
+
+        public enum EXT_texture_env_dot3 : uint
+        {
+            DOT3_RGB_EXT = 0x8740,
+            DOT3_RGBA_EXT = 0x8741,
+        }
+
+        public enum _3DFX_texture_compression_FXT1 : uint
+        {
+            COMPRESSED_RGBA_FXT1_3DFX = 0x86B1,
+            COMPRESSED_RGB_FXT1_3DFX = 0x86B0,
+        }
+
+        public enum REND_screen_coordinates : uint
+        {
+            SCREEN_COORDINATES_REND = 0x8490,
+            INVERTED_SCREEN_W_REND = 0x8491,
+        }
+
+        public enum SUN_triangle_list : uint
+        {
+            R1UI_N3F_V3F_SUN = 0x85C7,
+            REPLACE_MIDDLE_SUN = 0x0002,
+            REPLACE_OLDEST_SUN = 0x0003,
+            R1UI_V3F_SUN = 0x85C4,
+            REPLACEMENT_CODE_SUN = 0x81D8,
+            R1UI_T2F_N3F_V3F_SUN = 0x85CA,
+            RESTART_SUN = 0x0001,
+            REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2,
+            R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB,
+            R1UI_C4F_N3F_V3F_SUN = 0x85C8,
+            R1UI_T2F_V3F_SUN = 0x85C9,
+            TRIANGLE_LIST_SUN = 0x81D7,
+            REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1,
+            R1UI_C3F_V3F_SUN = 0x85C6,
+            R1UI_C4UB_V3F_SUN = 0x85C5,
+            REPLACEMENT_CODE_ARRAY_SUN = 0x85C0,
+            REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3,
+        }
+
+        public enum WIN_specular_fog : uint
+        {
+            FOG_SPECULAR_TEXTURE_WIN = 0x80EC,
+        }
+
+        public enum EXT_paletted_texture : uint
+        {
+            COLOR_INDEX1_EXT = 0x80E2,
+            TEXTURE_INDEX_SIZE_EXT = 0x80ED,
+            COLOR_INDEX8_EXT = 0x80E5,
+            COLOR_INDEX4_EXT = 0x80E4,
+            COLOR_INDEX12_EXT = 0x80E6,
+            COLOR_INDEX2_EXT = 0x80E3,
+            COLOR_INDEX16_EXT = 0x80E7,
+        }
+
+        public enum LogicOp : uint
+        {
+            SET = 0x150F,
+            EQUIV = 0x1509,
+            NAND = 0x150E,
+            NOR = 0x1508,
+            XOR = 0x1506,
+            OR = 0x1507,
+            COPY_INVERTED = 0x150C,
+            AND_INVERTED = 0x1504,
+            INVERT = 0x150A,
+            AND_REVERSE = 0x1502,
+            NOOP = 0x1505,
+            CLEAR = 0x1500,
+            OR_REVERSE = 0x150B,
+            OR_INVERTED = 0x150D,
+            AND = 0x1501,
+            COPY = 0x1503,
+        }
+
+        public enum EXT_index_func : uint
+        {
+            INDEX_TEST_FUNC_EXT = 0x81B6,
+            INDEX_TEST_EXT = 0x81B5,
+            INDEX_TEST_REF_EXT = 0x81B7,
+        }
+
+        public enum MESA_window_pos : uint
+        {
+        }
+
+        public enum DepthFunction : uint
+        {
+            NEVER = AlphaFunction.NEVER,
+            GEQUAL = AlphaFunction.GEQUAL,
+            GREATER = AlphaFunction.GREATER,
+            ALWAYS = AlphaFunction.ALWAYS,
+            LEQUAL = AlphaFunction.LEQUAL,
+            NOTEQUAL = AlphaFunction.NOTEQUAL,
+            EQUAL = AlphaFunction.EQUAL,
+            LESS = AlphaFunction.LESS,
+        }
+
+        public enum ARB_texture_non_power_of_two : uint
+        {
+        }
+
+        public enum SGIX_resample : uint
+        {
+            UNPACK_RESAMPLE_SGIX = 0x842D,
+            RESAMPLE_DECIMATE_SGIX = 0x8430,
+            RESAMPLE_REPLICATE_SGIX = 0x842E,
+            PACK_RESAMPLE_SGIX = 0x842C,
+            RESAMPLE_ZERO_FILL_SGIX = 0x842F,
+        }
+
+        public enum TextureFilterFuncSGIS : uint
+        {
+            FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
+        }
+
+        public enum ARB_fragment_program : uint
+        {
+            MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E,
+            PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805,
+            MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C,
+            MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810,
+            MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B,
+            MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872,
+            MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F,
+            MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D,
+            PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809,
+            PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806,
+            PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807,
+            PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A,
+            FRAGMENT_PROGRAM_ARB = 0x8804,
+            PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808,
+            MAX_TEXTURE_COORDS_ARB = 0x8871,
+        }
+
+        public enum SGIX_ycrcba : uint
+        {
+            YCRCBA_SGIX = 0x8319,
+            YCRCB_SGIX = 0x8318,
+        }
+
+        public enum EXT_convolution : uint
+        {
+            CONVOLUTION_WIDTH = 0x8018,
+            CONVOLUTION_1D = 0x8010,
+            CONVOLUTION_FILTER_SCALE_EXT = 0x8014,
+            CONVOLUTION_2D = 0x8011,
+            CONVOLUTION_WIDTH_EXT = 0x8018,
+            POST_CONVOLUTION_ALPHA_BIAS = 0x8023,
+            POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F,
+            POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022,
+            CONVOLUTION_FILTER_SCALE = 0x8014,
+            POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D,
+            SEPARABLE_2D = 0x8012,
+            CONVOLUTION_FORMAT = 0x8017,
+            POST_CONVOLUTION_BLUE_SCALE = 0x801E,
+            CONVOLUTION_BORDER_MODE_EXT = 0x8013,
+            POST_CONVOLUTION_GREEN_SCALE = 0x801D,
+            POST_CONVOLUTION_RED_SCALE_EXT = 0x801C,
+            REDUCE_EXT = 0x8016,
+            CONVOLUTION_1D_EXT = 0x8010,
+            MAX_CONVOLUTION_WIDTH_EXT = 0x801A,
+            CONVOLUTION_FORMAT_EXT = 0x8017,
+            POST_CONVOLUTION_BLUE_BIAS = 0x8022,
+            CONVOLUTION_HEIGHT = 0x8019,
+            SEPARABLE_2D_EXT = 0x8012,
+            CONVOLUTION_2D_EXT = 0x8011,
+            MAX_CONVOLUTION_WIDTH = 0x801A,
+            POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023,
+            POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021,
+            POST_CONVOLUTION_RED_BIAS_EXT = 0x8020,
+            REDUCE = 0x8016,
+            MAX_CONVOLUTION_HEIGHT_EXT = 0x801B,
+            CONVOLUTION_BORDER_MODE = 0x8013,
+            POST_CONVOLUTION_ALPHA_SCALE = 0x801F,
+            POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E,
+            POST_CONVOLUTION_RED_BIAS = 0x8020,
+            CONVOLUTION_FILTER_BIAS_EXT = 0x8015,
+            POST_CONVOLUTION_RED_SCALE = 0x801C,
+            CONVOLUTION_HEIGHT_EXT = 0x8019,
+            MAX_CONVOLUTION_HEIGHT = 0x801B,
+            CONVOLUTION_FILTER_BIAS = 0x8015,
+            POST_CONVOLUTION_GREEN_BIAS = 0x8021,
+        }
+
+        public enum MaterialParameter : uint
+        {
+            EMISSION = 0x1600,
+            DIFFUSE = LightParameter.DIFFUSE,
+            AMBIENT_AND_DIFFUSE = 0x1602,
+            SHININESS = 0x1601,
+            SPECULAR = LightParameter.SPECULAR,
+            AMBIENT = LightParameter.AMBIENT,
+            COLOR_INDEXES = 0x1603,
+        }
+
+        public enum EXT_index_texture : uint
+        {
+        }
+
+        public enum SeparableTargetEXT : uint
+        {
+            SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
+        }
+
+        public enum HP_convolution_border_modes : uint
+        {
+            IGNORE_BORDER_HP = 0x8150,
+            CONVOLUTION_BORDER_COLOR = 0x8154,
+            CONVOLUTION_BORDER_COLOR_HP = 0x8154,
+            REPLICATE_BORDER_HP = 0x8153,
+            CONSTANT_BORDER = 0x8151,
+            CONSTANT_BORDER_HP = 0x8151,
+            REPLICATE_BORDER = 0x8153,
+        }
+
+        public enum NV_vertex_program3 : uint
+        {
+            MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = ARB_vertex_shader.MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,
+        }
+
+        public enum NV_blend_square : uint
+        {
+        }
+
+        public enum PointParameterNameSGIS : uint
+        {
+            DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS,
+            POINT_SIZE_MAX_SGIS = SGIS_point_parameters.POINT_SIZE_MAX_SGIS,
+            POINT_FADE_THRESHOLD_SIZE_SGIS = SGIS_point_parameters.POINT_FADE_THRESHOLD_SIZE_SGIS,
+            POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_SGIS,
+        }
+
+        public enum EXT_texture_mirror_clamp : uint
+        {
+            MIRROR_CLAMP_TO_BORDER_EXT = 0x8912,
+            MIRROR_CLAMP_TO_EDGE_EXT = 0x8743,
+            MIRROR_CLAMP_EXT = 0x8742,
+        }
+
+        public enum NV_pixel_data_range : uint
+        {
+            READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B,
+            WRITE_PIXEL_DATA_RANGE_NV = 0x8878,
+            WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C,
+            READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D,
+            WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A,
+            READ_PIXEL_DATA_RANGE_NV = 0x8879,
+        }
+
+        public enum PixelInternalFormat : uint
+        {
+            LUMINANCE12_ALPHA12 = 0x8047,
+            DUAL_LUMINANCE16_SGIS = SGIS_texture_select.DUAL_LUMINANCE16_SGIS,
+            QUAD_LUMINANCE8_SGIS = SGIS_texture_select.QUAD_LUMINANCE8_SGIS,
+            RGBA16 = 0x805B,
+            ALPHA_ICC_SGIX = SGIX_icc_texture.ALPHA_ICC_SGIX,
+            LUMINANCE12 = 0x8041,
+            DUAL_ALPHA4_SGIS = SGIS_texture_select.DUAL_ALPHA4_SGIS,
+            INTENSITY4 = 0x804A,
+            RGBA12 = 0x805A,
+            INTENSITY8 = 0x804B,
+            DUAL_ALPHA8_SGIS = SGIS_texture_select.DUAL_ALPHA8_SGIS,
+            DEPTH_COMPONENT16_SGIX = SGIX_depth_texture.DEPTH_COMPONENT16_SGIX,
+            ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX,
+            DUAL_INTENSITY12_SGIS = SGIS_texture_select.DUAL_INTENSITY12_SGIS,
+            LUMINANCE16 = 0x8042,
+            LUMINANCE_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ICC_SGIX,
+            DEPTH_COMPONENT24_SGIX = SGIX_depth_texture.DEPTH_COMPONENT24_SGIX,
+            INTENSITY = 0x8049,
+            QUAD_ALPHA4_SGIS = SGIS_texture_select.QUAD_ALPHA4_SGIS,
+            ALPHA12 = 0x803D,
+            INTENSITY_ICC_SGIX = SGIX_icc_texture.INTENSITY_ICC_SGIX,
+            LUMINANCE4 = 0x803F,
+            LUMINANCE_ALPHA_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ALPHA_ICC_SGIX,
+            RGB_ICC_SGIX = SGIX_icc_texture.RGB_ICC_SGIX,
+            LUMINANCE4_ALPHA4 = 0x8043,
+            INTENSITY16_ICC_SGIX = SGIX_icc_texture.INTENSITY16_ICC_SGIX,
+            RGBA_ICC_SGIX = SGIX_icc_texture.RGBA_ICC_SGIX,
+            DUAL_LUMINANCE12_SGIS = SGIS_texture_select.DUAL_LUMINANCE12_SGIS,
+            ALPHA16 = 0x803E,
+            DUAL_ALPHA16_SGIS = SGIS_texture_select.DUAL_ALPHA16_SGIS,
+            DUAL_ALPHA12_SGIS = SGIS_texture_select.DUAL_ALPHA12_SGIS,
+            RGB2_EXT = EXT_texture.RGB2_EXT,
+            LUMINANCE8 = 0x8040,
+            QUAD_INTENSITY8_SGIS = SGIS_texture_select.QUAD_INTENSITY8_SGIS,
+            DUAL_LUMINANCE_ALPHA4_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA4_SGIS,
+            LUMINANCE12_ALPHA4 = 0x8046,
+            QUAD_LUMINANCE4_SGIS = SGIS_texture_select.QUAD_LUMINANCE4_SGIS,
+            RGB5 = 0x8050,
+            DUAL_LUMINANCE_ALPHA8_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA8_SGIS,
+            LUMINANCE8_ALPHA8 = 0x8045,
+            DUAL_INTENSITY8_SGIS = SGIS_texture_select.DUAL_INTENSITY8_SGIS,
+            RGB8 = 0x8051,
+            R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX,
+            QUAD_ALPHA8_SGIS = SGIS_texture_select.QUAD_ALPHA8_SGIS,
+            DUAL_INTENSITY4_SGIS = SGIS_texture_select.DUAL_INTENSITY4_SGIS,
+            RGB10_A2 = 0x8059,
+            INTENSITY12 = 0x804C,
+            RGBA4 = 0x8056,
+            RGB5_A1 = 0x8057,
+            R3_G3_B2 = 0x2A10,
+            R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX,
+            RGBA2 = 0x8055,
+            DUAL_INTENSITY16_SGIS = SGIS_texture_select.DUAL_INTENSITY16_SGIS,
+            QUAD_INTENSITY4_SGIS = SGIS_texture_select.QUAD_INTENSITY4_SGIS,
+            DUAL_LUMINANCE8_SGIS = SGIS_texture_select.DUAL_LUMINANCE8_SGIS,
+            RGB16 = 0x8054,
+            ALPHA4 = 0x803B,
+            RGBA8 = 0x8058,
+            INTENSITY16 = 0x804D,
+            LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX,
+            LUMINANCE16_ALPHA16 = 0x8048,
+            LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX,
+            ALPHA8 = 0x803C,
+            RGB4 = 0x804F,
+            DEPTH_COMPONENT32_SGIX = SGIX_depth_texture.DEPTH_COMPONENT32_SGIX,
+            RGB10 = 0x8052,
+            RGB12 = 0x8053,
+            LUMINANCE6_ALPHA2 = 0x8044,
+            DUAL_LUMINANCE4_SGIS = SGIS_texture_select.DUAL_LUMINANCE4_SGIS,
+        }
+
+        public enum ARB_vertex_blend : uint
+        {
+            MODELVIEW5_ARB = 0x8725,
+            MODELVIEW0_ARB = 0x1700,
+            ACTIVE_VERTEX_UNITS_ARB = 0x86A5,
+            MODELVIEW6_ARB = 0x8726,
+            MODELVIEW4_ARB = 0x8724,
+            WEIGHT_ARRAY_ARB = 0x86AD,
+            MODELVIEW15_ARB = 0x872F,
+            MODELVIEW10_ARB = 0x872A,
+            MODELVIEW16_ARB = 0x8730,
+            MODELVIEW21_ARB = 0x8735,
+            MODELVIEW22_ARB = 0x8736,
+            WEIGHT_ARRAY_POINTER_ARB = 0x86AC,
+            WEIGHT_SUM_UNITY_ARB = 0x86A6,
+            MODELVIEW1_ARB = 0x850A,
+            MODELVIEW29_ARB = 0x873D,
+            MODELVIEW11_ARB = 0x872B,
+            MODELVIEW12_ARB = 0x872C,
+            MODELVIEW19_ARB = 0x8733,
+            VERTEX_BLEND_ARB = 0x86A7,
+            MODELVIEW26_ARB = 0x873A,
+            MODELVIEW17_ARB = 0x8731,
+            CURRENT_WEIGHT_ARB = 0x86A8,
+            MODELVIEW27_ARB = 0x873B,
+            MODELVIEW23_ARB = 0x8737,
+            WEIGHT_ARRAY_SIZE_ARB = 0x86AB,
+            MAX_VERTEX_UNITS_ARB = 0x86A4,
+            MODELVIEW7_ARB = 0x8727,
+            MODELVIEW13_ARB = 0x872D,
+            MODELVIEW28_ARB = 0x873C,
+            MODELVIEW25_ARB = 0x8739,
+            WEIGHT_ARRAY_TYPE_ARB = 0x86A9,
+            MODELVIEW8_ARB = 0x8728,
+            WEIGHT_ARRAY_STRIDE_ARB = 0x86AA,
+            MODELVIEW18_ARB = 0x8732,
+            MODELVIEW9_ARB = 0x8729,
+            MODELVIEW24_ARB = 0x8738,
+            MODELVIEW14_ARB = 0x872E,
+            MODELVIEW20_ARB = 0x8734,
+            MODELVIEW31_ARB = 0x873F,
+            MODELVIEW30_ARB = 0x873E,
+            MODELVIEW2_ARB = 0x8722,
+            MODELVIEW3_ARB = 0x8723,
+        }
+
+        public enum AttribMask : uint
+        {
+            POLYGON_BIT = 0x00000008,
+            TRANSFORM_BIT = 0x00001000,
+            COLOR_BUFFER_BIT = 0x00004000,
+            LINE_BIT = 0x00000004,
+            POINT_BIT = 0x00000002,
+            EVAL_BIT = 0x00010000,
+            LIST_BIT = 0x00020000,
+            FOG_BIT = 0x00000080,
+            HINT_BIT = 0x00008000,
+            ENABLE_BIT = 0x00002000,
+            STENCIL_BUFFER_BIT = 0x00000400,
+            TEXTURE_BIT = 0x00040000,
+            ACCUM_BUFFER_BIT = 0x00000200,
+            LIGHTING_BIT = 0x00000040,
+            CURRENT_BIT = 0x00000001,
+            ALL_ATTRIB_BITS = 0xFFFFFFFF,
+            DEPTH_BUFFER_BIT = 0x00000100,
+            POLYGON_STIPPLE_BIT = 0x00000010,
+            SCISSOR_BIT = 0x00080000,
+            VIEWPORT_BIT = 0x00000800,
+            PIXEL_MODE_BIT = 0x00000020,
+        }
+
+        public enum SGIX_pixel_texture : uint
+        {
+            PIXEL_TEX_GEN_SGIX = 0x8139,
+            PIXEL_TEX_GEN_MODE_SGIX = 0x832B,
+        }
+
+        public enum SGIX_framezoom : uint
+        {
+            FRAMEZOOM_FACTOR_SGIX = 0x818C,
+            MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D,
+            FRAMEZOOM_SGIX = 0x818B,
+        }
+
+        public enum TextureGenParameter : uint
+        {
+            EYE_PLANE = 0x2502,
+            OBJECT_LINE_SGIS = SGIS_point_line_texgen.OBJECT_LINE_SGIS,
+            EYE_POINT_SGIS = SGIS_point_line_texgen.EYE_POINT_SGIS,
+            TEXTURE_GEN_MODE = 0x2500,
+            EYE_LINE_SGIS = SGIS_point_line_texgen.EYE_LINE_SGIS,
+            OBJECT_POINT_SGIS = SGIS_point_line_texgen.OBJECT_POINT_SGIS,
+            OBJECT_PLANE = 0x2501,
+        }
+
+        public enum ReadBufferMode : uint
+        {
+            FRONT_RIGHT = DrawBufferMode.FRONT_RIGHT,
+            AUX3 = DrawBufferMode.AUX3,
+            AUX1 = DrawBufferMode.AUX1,
+            LEFT = DrawBufferMode.LEFT,
+            RIGHT = DrawBufferMode.RIGHT,
+            BACK_RIGHT = DrawBufferMode.BACK_RIGHT,
+            AUX2 = DrawBufferMode.AUX2,
+            AUX0 = DrawBufferMode.AUX0,
+            FRONT_LEFT = DrawBufferMode.FRONT_LEFT,
+            BACK = DrawBufferMode.BACK,
+            FRONT = DrawBufferMode.FRONT,
+            BACK_LEFT = DrawBufferMode.BACK_LEFT,
+        }
+
+        public enum FeedBackToken : uint
+        {
+            BITMAP_TOKEN = 0x0704,
+            LINE_TOKEN = 0x0702,
+            PASS_THROUGH_TOKEN = 0x0700,
+            LINE_RESET_TOKEN = 0x0707,
+            POINT_TOKEN = 0x0701,
+            COPY_PIXEL_TOKEN = 0x0706,
+            DRAW_PIXEL_TOKEN = 0x0705,
+            POLYGON_TOKEN = 0x0703,
+        }
+
+        public enum TextureMinFilter : uint
+        {
+            LINEAR = TextureMagFilter.LINEAR,
+            PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX,
+            FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
+            PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX,
+            NEAREST_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_NEAREST_SGIX,
+            LINEAR_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_NEAREST_SGIX,
+            NEAREST_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_LINEAR_SGIX,
+            NEAREST_MIPMAP_LINEAR = 0x2702,
+            NEAREST = TextureMagFilter.NEAREST,
+            NEAREST_MIPMAP_NEAREST = 0x2700,
+            LINEAR_MIPMAP_NEAREST = 0x2701,
+            LINEAR_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_LINEAR_SGIX,
+            LINEAR_MIPMAP_LINEAR = 0x2703,
+            PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX,
+        }
+
+        public enum APPLE_element_array : uint
+        {
+            ELEMENT_ARRAY_POINTER_APPLE = 0x876A,
+            ELEMENT_ARRAY_APPLE = 0x8768,
+            ELEMENT_ARRAY_TYPE_APPLE = 0x8769,
+        }
+
+        public enum VERSION_1_5 : uint
+        {
+            DYNAMIC_READ = 0x88E9,
+            VERTEX_ARRAY_BUFFER_BINDING = 0x8896,
+            STREAM_COPY = 0x88E2,
+            FOG_COORD_ARRAY_STRIDE = VERSION_1_4.FOG_COORDINATE_ARRAY_STRIDE,
+            FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D,
+            READ_WRITE = 0x88BA,
+            SRC1_ALPHA = VERSION_1_3.SOURCE1_ALPHA,
+            TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A,
+            BUFFER_MAP_POINTER = 0x88BD,
+            QUERY_COUNTER_BITS = 0x8864,
+            STATIC_COPY = 0x88E6,
+            STATIC_DRAW = 0x88E4,
+            SRC2_RGB = VERSION_1_3.SOURCE2_RGB,
+            SRC2_ALPHA = VERSION_1_3.SOURCE2_ALPHA,
+            FOG_COORD_ARRAY = VERSION_1_4.FOG_COORDINATE_ARRAY,
+            FOG_COORD_SRC = VERSION_1_4.FOG_COORDINATE_SOURCE,
+            DYNAMIC_COPY = 0x88EA,
+            STATIC_READ = 0x88E5,
+            FOG_COORD_ARRAY_BUFFER_BINDING = VERSION_1_5.FOG_COORDINATE_ARRAY_BUFFER_BINDING,
+            FOG_COORD_ARRAY_POINTER = VERSION_1_4.FOG_COORDINATE_ARRAY_POINTER,
+            EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B,
+            CURRENT_FOG_COORD = VERSION_1_4.CURRENT_FOG_COORDINATE,
+            VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F,
+            READ_ONLY = 0x88B8,
+            SRC0_ALPHA = VERSION_1_3.SOURCE0_ALPHA,
+            ELEMENT_ARRAY_BUFFER = 0x8893,
+            CURRENT_QUERY = 0x8865,
+            FOG_COORD = VERSION_1_4.FOG_COORDINATE,
+            QUERY_RESULT = 0x8866,
+            BUFFER_USAGE = 0x8765,
+            BUFFER_ACCESS = 0x88BB,
+            STREAM_DRAW = 0x88E0,
+            SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C,
+            SRC0_RGB = VERSION_1_3.SOURCE0_RGB,
+            ARRAY_BUFFER_BINDING = 0x8894,
+            QUERY_RESULT_AVAILABLE = 0x8867,
+            WRITE_ONLY = 0x88B9,
+            BUFFER_SIZE = 0x8764,
+            WEIGHT_ARRAY_BUFFER_BINDING = 0x889E,
+            SRC1_RGB = VERSION_1_3.SOURCE1_RGB,
+            SAMPLES_PASSED = 0x8914,
+            DYNAMIC_DRAW = 0x88E8,
+            ARRAY_BUFFER = 0x8892,
+            NORMAL_ARRAY_BUFFER_BINDING = 0x8897,
+            COLOR_ARRAY_BUFFER_BINDING = 0x8898,
+            INDEX_ARRAY_BUFFER_BINDING = 0x8899,
+            BUFFER_MAPPED = 0x88BC,
+            ELEMENT_ARRAY_BUFFER_BINDING = 0x8895,
+            STREAM_READ = 0x88E1,
+            FOG_COORD_ARRAY_TYPE = VERSION_1_4.FOG_COORDINATE_ARRAY_TYPE,
+        }
+
+        public enum ErrorCode : uint
+        {
+            OUT_OF_MEMORY = 0x0505,
+            TEXTURE_TOO_LARGE_EXT = EXT_texture.TEXTURE_TOO_LARGE_EXT,
+            STACK_OVERFLOW = 0x0503,
+            INVALID_ENUM = 0x0500,
+            INVALID_VALUE = 0x0501,
+            TABLE_TOO_LARGE_EXT = EXT_histogram.TABLE_TOO_LARGE_EXT,
+            INVALID_OPERATION = 0x0502,
+            STACK_UNDERFLOW = 0x0504,
+            NO_ERROR = 0,
+        }
+
+        public enum GetPointervPName : uint
+        {
+            FEEDBACK_BUFFER_POINTER = 0x0DF0,
+            EDGE_FLAG_ARRAY_POINTER = 0x8093,
+            TEXTURE_COORD_ARRAY_POINTER = 0x8092,
+            INDEX_ARRAY_POINTER = 0x8091,
+            INSTRUMENT_BUFFER_POINTER_SGIX = SGIX_instruments.INSTRUMENT_BUFFER_POINTER_SGIX,
+            SELECTION_BUFFER_POINTER = 0x0DF3,
+            NORMAL_ARRAY_POINTER = 0x808F,
+            VERTEX_ARRAY_POINTER = 0x808E,
+            COLOR_ARRAY_POINTER = 0x8090,
+        }
+
+        public enum BlendingFactorSrc : uint
+        {
+            ZERO = BlendingFactorDest.ZERO,
+            ONE_MINUS_SRC_ALPHA = BlendingFactorDest.ONE_MINUS_SRC_ALPHA,
+            ONE_MINUS_DST_COLOR = 0x0307,
+            ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT,
+            CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT,
+            DST_ALPHA = BlendingFactorDest.DST_ALPHA,
+            CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT,
+            SRC_ALPHA = BlendingFactorDest.SRC_ALPHA,
+            SRC_ALPHA_SATURATE = 0x0308,
+            ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT,
+            ONE_MINUS_DST_ALPHA = BlendingFactorDest.ONE_MINUS_DST_ALPHA,
+            DST_COLOR = 0x0306,
+            ONE = BlendingFactorDest.ONE,
+        }
+
+        public enum APPLE_vertex_array_object : uint
+        {
+            VERTEX_ARRAY_BINDING_APPLE = 0x85B5,
+        }
+
+        public enum ATI_fragment_shader : uint
+        {
+            REG_16_ATI = 0x8931,
+            CON_12_ATI = 0x894D,
+            REG_14_ATI = 0x892F,
+            CON_14_ATI = 0x894F,
+            HALF_BIT_ATI = 0x00000008,
+            NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973,
+            REG_25_ATI = 0x893A,
+            REG_10_ATI = 0x892B,
+            CON_6_ATI = 0x8947,
+            REG_15_ATI = 0x8930,
+            REG_2_ATI = 0x8923,
+            NUM_FRAGMENT_CONSTANTS_ATI = 0x896F,
+            QUARTER_BIT_ATI = 0x00000010,
+            REG_19_ATI = 0x8934,
+            CON_27_ATI = 0x895C,
+            NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971,
+            FRAGMENT_SHADER_ATI = 0x8920,
+            NUM_PASSES_ATI = 0x8970,
+            REG_28_ATI = 0x893D,
+            CON_1_ATI = 0x8942,
+            REG_3_ATI = 0x8924,
+            CON_9_ATI = 0x894A,
+            CON_4_ATI = 0x8945,
+            CON_18_ATI = 0x8953,
+            REG_27_ATI = 0x893C,
+            REG_22_ATI = 0x8937,
+            REG_21_ATI = 0x8936,
+            SWIZZLE_STR_DR_ATI = 0x8978,
+            REG_20_ATI = 0x8935,
+            CON_21_ATI = 0x8956,
+            MUL_ATI = 0x8964,
+            SATURATE_BIT_ATI = 0x00000040,
+            REG_0_ATI = 0x8921,
+            MOV_ATI = 0x8961,
+            SWIZZLE_STQ_DQ_ATI = 0x8979,
+            SWIZZLE_STQ_ATI = 0x8977,
+            SWIZZLE_STR_ATI = 0x8976,
+            REG_8_ATI = 0x8929,
+            CON_10_ATI = 0x894B,
+            CON_7_ATI = 0x8948,
+            DOT2_ADD_ATI = 0x896C,
+            CON_16_ATI = 0x8951,
+            CON_22_ATI = 0x8957,
+            REG_31_ATI = 0x8940,
+            MAD_ATI = 0x8968,
+            COLOR_ALPHA_PAIRING_ATI = 0x8975,
+            CON_24_ATI = 0x8959,
+            REG_30_ATI = 0x893F,
+            CON_13_ATI = 0x894E,
+            REG_1_ATI = 0x8922,
+            CON_15_ATI = 0x8950,
+            REG_18_ATI = 0x8933,
+            SECONDARY_INTERPOLATOR_ATI = 0x896D,
+            REG_9_ATI = 0x892A,
+            BLUE_BIT_ATI = 0x00000004,
+            CON_2_ATI = 0x8943,
+            LERP_ATI = 0x8969,
+            REG_17_ATI = 0x8932,
+            _4X_BIT_ATI = 0x00000002,
+            REG_12_ATI = 0x892D,
+            REG_11_ATI = 0x892C,
+            CND0_ATI = 0x896B,
+            REG_6_ATI = 0x8927,
+            REG_23_ATI = 0x8938,
+            CON_29_ATI = 0x895E,
+            SWIZZLE_STRQ_DQ_ATI = 0x897B,
+            NEGATE_BIT_ATI = 0x00000004,
+            CON_31_ATI = 0x8960,
+            CON_5_ATI = 0x8946,
+            _8X_BIT_ATI = 0x00000004,
+            CON_8_ATI = 0x8949,
+            COMP_BIT_ATI = 0x00000002,
+            REG_26_ATI = 0x893B,
+            CON_26_ATI = 0x895B,
+            REG_24_ATI = 0x8939,
+            BIAS_BIT_ATI = 0x00000008,
+            RED_BIT_ATI = 0x00000001,
+            CON_28_ATI = 0x895D,
+            CND_ATI = 0x896A,
+            CON_17_ATI = 0x8952,
+            REG_7_ATI = 0x8928,
+            CON_19_ATI = 0x8954,
+            EIGHTH_BIT_ATI = 0x00000020,
+            CON_30_ATI = 0x895F,
+            NUM_LOOPBACK_COMPONENTS_ATI = 0x8974,
+            REG_4_ATI = 0x8925,
+            CON_0_ATI = 0x8941,
+            ADD_ATI = 0x8963,
+            GREEN_BIT_ATI = 0x00000002,
+            DOT3_ATI = 0x8966,
+            CON_20_ATI = 0x8955,
+            REG_29_ATI = 0x893E,
+            CON_11_ATI = 0x894C,
+            CON_3_ATI = 0x8944,
+            NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972,
+            SUB_ATI = 0x8965,
+            _2X_BIT_ATI = 0x00000001,
+            NUM_FRAGMENT_REGISTERS_ATI = 0x896E,
+            REG_13_ATI = 0x892E,
+            CON_23_ATI = 0x8958,
+            DOT4_ATI = 0x8967,
+            SWIZZLE_STRQ_ATI = 0x897A,
+            REG_5_ATI = 0x8926,
+            CON_25_ATI = 0x895A,
+        }
+
+        public enum SGIX_list_priority : uint
+        {
+            LIST_PRIORITY_SGIX = 0x8182,
+        }
+
+        public enum FeedbackType : uint
+        {
+            _3D_COLOR_TEXTURE = 0x0603,
+            _4D_COLOR_TEXTURE = 0x0604,
+            _3D_COLOR = 0x0602,
+            _2D = 0x0600,
+            _3D = 0x0601,
+        }
+
+        public enum GREMEDY_string_marker : uint
+        {
+        }
+
+        public enum ARB_point_sprite : uint
+        {
+            POINT_SPRITE_ARB = 0x8861,
+            COORD_REPLACE_ARB = 0x8862,
+        }
+
+        public enum INGR_color_clamp : uint
+        {
+            BLUE_MIN_CLAMP_INGR = 0x8562,
+            RED_MAX_CLAMP_INGR = 0x8564,
+            ALPHA_MAX_CLAMP_INGR = 0x8567,
+            ALPHA_MIN_CLAMP_INGR = 0x8563,
+            GREEN_MAX_CLAMP_INGR = 0x8565,
+            BLUE_MAX_CLAMP_INGR = 0x8566,
+            GREEN_MIN_CLAMP_INGR = 0x8561,
+            RED_MIN_CLAMP_INGR = 0x8560,
+        }
+
+        public enum PGI_misc_hints : uint
+        {
+            FULL_STIPPLE_HINT_PGI = 0x1A219,
+            BACK_NORMALS_HINT_PGI = 0x1A223,
+            ALLOW_DRAW_MEM_HINT_PGI = 0x1A211,
+            ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F,
+            ALWAYS_FAST_HINT_PGI = 0x1A20C,
+            NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202,
+            CONSERVE_MEMORY_HINT_PGI = 0x1A1FD,
+            PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8,
+            STRICT_LIGHTING_HINT_PGI = 0x1A217,
+            CLIP_FAR_HINT_PGI = 0x1A221,
+            CLIP_NEAR_HINT_PGI = 0x1A220,
+            STRICT_SCISSOR_HINT_PGI = 0x1A218,
+            ALLOW_DRAW_FRG_HINT_PGI = 0x1A210,
+            ALWAYS_SOFT_HINT_PGI = 0x1A20D,
+            NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203,
+            ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E,
+            NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204,
+            RECLAIM_MEMORY_HINT_PGI = 0x1A1FE,
+            STRICT_DEPTHFUNC_HINT_PGI = 0x1A216,
+            WIDE_LINE_HINT_PGI = 0x1A222,
+        }
+
+        public enum SGIS_pixel_texture : uint
+        {
+            PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354,
+            PIXEL_TEXTURE_SGIS = 0x8353,
+            PIXEL_GROUP_COLOR_SGIS = 0x8356,
+            PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355,
+        }
+
+        public enum VERSION_2_1 : uint
+        {
+            FLOAT_MAT3x2 = 0x8B67,
+            SRGB8 = 0x8C41,
+            FLOAT_MAT3x4 = 0x8B68,
+            COMPRESSED_SRGB_ALPHA = 0x8C49,
+            FLOAT_MAT4x3 = 0x8B6A,
+            SLUMINANCE_ALPHA = 0x8C44,
+            PIXEL_UNPACK_BUFFER = 0x88EC,
+            SRGB_ALPHA = 0x8C42,
+            COMPRESSED_SLUMINANCE = 0x8C4A,
+            FLOAT_MAT4x2 = 0x8B69,
+            SRGB8_ALPHA8 = 0x8C43,
+            COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B,
+            PIXEL_UNPACK_BUFFER_BINDING = 0x88EF,
+            PIXEL_PACK_BUFFER = 0x88EB,
+            FLOAT_MAT2x3 = 0x8B65,
+            COMPRESSED_SRGB = 0x8C48,
+            PIXEL_PACK_BUFFER_BINDING = 0x88ED,
+            SRGB = 0x8C40,
+            SLUMINANCE8 = 0x8C47,
+            SLUMINANCE = 0x8C46,
+            FLOAT_MAT2x4 = 0x8B66,
+            SLUMINANCE8_ALPHA8 = 0x8C45,
+            CURRENT_RASTER_SECONDARY_COLOR = 0x845F,
+        }
+
+        public enum APPLE_ycbcr_422 : uint
+        {
+            UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB,
+            YCBCR_422_APPLE = 0x85B9,
+            UNSIGNED_SHORT_8_8_APPLE = 0x85BA,
+        }
+
+        public enum ARB_vertex_shader : uint
+        {
+            MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D,
+            VERTEX_SHADER_ARB = 0x8B31,
+            OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89,
+            MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C,
+            MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A,
+            MAX_VARYING_FLOATS_ARB = 0x8B4B,
+            OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A,
+        }
+
+        public enum EXT_shadow_funcs : uint
+        {
+        }
+
+        public enum EXT_blend_func_separate : uint
+        {
+            BLEND_SRC_ALPHA_EXT = 0x80CB,
+            BLEND_DST_RGB_EXT = 0x80C8,
+            BLEND_DST_ALPHA_EXT = 0x80CA,
+            BLEND_SRC_RGB_EXT = 0x80C9,
+        }
+
+        public enum SGIS_texture_lod : uint
+        {
+            TEXTURE_MAX_LOD_SGIS = 0x813B,
+            TEXTURE_MAX_LEVEL = 0x813D,
+            TEXTURE_BASE_LEVEL_SGIS = 0x813C,
+            TEXTURE_MIN_LOD_SGIS = 0x813A,
+            TEXTURE_MIN_LOD = 0x813A,
+            TEXTURE_MAX_LOD = 0x813B,
+            TEXTURE_BASE_LEVEL = 0x813C,
+            TEXTURE_MAX_LEVEL_SGIS = 0x813D,
+        }
+
+        public enum SGIX_depth_texture : uint
+        {
+            DEPTH_COMPONENT16_SGIX = 0x81A5,
+            DEPTH_COMPONENT32_SGIX = 0x81A7,
+            DEPTH_COMPONENT16 = 0x81A5,
+            DEPTH_COMPONENT24 = 0x81A6,
+            DEPTH_COMPONENT24_SGIX = 0x81A6,
+            DEPTH_COMPONENT32 = 0x81A7,
+        }
+
+        public enum EXT_texture_perturb_normal : uint
+        {
+            TEXTURE_NORMAL_EXT = 0x85AF,
+            PERTURB_EXT = 0x85AE,
+        }
+
+        public enum EXT_light_texture : uint
+        {
+            ATTENUATION_EXT = 0x834D,
+            FRAGMENT_DEPTH_EXT = EXT_fog_coord.FRAGMENT_DEPTH_EXT,
+            TEXTURE_LIGHT_EXT = 0x8350,
+            FRAGMENT_NORMAL_EXT = 0x834A,
+            FRAGMENT_MATERIAL_EXT = 0x8349,
+            TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352,
+            TEXTURE_MATERIAL_FACE_EXT = 0x8351,
+            SHADOW_ATTENUATION_EXT = 0x834E,
+            FRAGMENT_COLOR_EXT = 0x834C,
+            TEXTURE_APPLICATION_MODE_EXT = 0x834F,
+        }
+
+        public enum Boolean : uint
+        {
+            TRUE = 1,
+            FALSE = 0,
+        }
+
+        public enum ARB_texture_rectangle : uint
+        {
+            TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6,
+            TEXTURE_RECTANGLE_ARB = 0x84F5,
+            MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8,
+            PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7,
+        }
+
+        public enum SGIX_reference_plane : uint
+        {
+            REFERENCE_PLANE_EQUATION_SGIX = 0x817E,
+            REFERENCE_PLANE_SGIX = 0x817D,
+        }
+
+        public enum StencilOp : uint
+        {
+            REPLACE = 0x1E01,
+            DECR = 0x1E03,
+            INVERT = LogicOp.INVERT,
+            INCR = 0x1E02,
+            KEEP = 0x1E00,
+            ZERO = BlendingFactorDest.ZERO,
+        }
+
+        public enum EXT_multisample : uint
+        {
+            SAMPLE_MASK_EXT = 0x80A0,
+            MULTISAMPLE_EXT = 0x809D,
+            _4PASS_3_EXT = 0x80A7,
+            _4PASS_2_EXT = 0x80A6,
+            SAMPLE_PATTERN_EXT = 0x80AC,
+            SAMPLE_ALPHA_TO_MASK_EXT = 0x809E,
+            _2PASS_1_EXT = 0x80A3,
+            SAMPLES_EXT = 0x80A9,
+            SAMPLE_MASK_INVERT_EXT = 0x80AB,
+            SAMPLE_BUFFERS_EXT = 0x80A8,
+            MULTISAMPLE_BIT_EXT = 0x20000000,
+            _4PASS_1_EXT = 0x80A5,
+            SAMPLE_MASK_VALUE_EXT = 0x80AA,
+            _2PASS_0_EXT = 0x80A2,
+            _1PASS_EXT = 0x80A1,
+            _4PASS_0_EXT = 0x80A4,
+            SAMPLE_ALPHA_TO_ONE_EXT = 0x809F,
+        }
+
+        public enum HP_texture_lighting : uint
+        {
+            TEXTURE_LIGHTING_MODE_HP = 0x8167,
+            TEXTURE_PRE_SPECULAR_HP = 0x8169,
+            TEXTURE_POST_SPECULAR_HP = 0x8168,
+        }
+
+        public enum ARB_shadow : uint
+        {
+            TEXTURE_COMPARE_MODE_ARB = 0x884C,
+            TEXTURE_COMPARE_FUNC_ARB = 0x884D,
+            COMPARE_R_TO_TEXTURE_ARB = 0x884E,
+        }
+
+        public enum SGIS_texture4D : uint
+        {
+            TEXTURE_4D_BINDING_SGIS = 0x814F,
+            PACK_IMAGE_DEPTH_SGIS = 0x8131,
+            MAX_4D_TEXTURE_SIZE_SGIS = 0x8138,
+            PACK_SKIP_VOLUMES_SGIS = 0x8130,
+            TEXTURE_4D_SGIS = 0x8134,
+            PROXY_TEXTURE_4D_SGIS = 0x8135,
+            UNPACK_IMAGE_DEPTH_SGIS = 0x8133,
+            UNPACK_SKIP_VOLUMES_SGIS = 0x8132,
+            TEXTURE_4DSIZE_SGIS = 0x8136,
+            TEXTURE_WRAP_Q_SGIS = 0x8137,
+        }
+
+        public enum ColorPointerType : uint
+        {
+            UNSIGNED_INT = DataType.UNSIGNED_INT,
+            FLOAT = DataType.FLOAT,
+            UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
+            SHORT = DataType.SHORT,
+            BYTE = DataType.BYTE,
+            INT = DataType.INT,
+            UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
+            DOUBLE = DataType.DOUBLE,
+        }
+
+        public enum VertexPointerType : uint
+        {
+            DOUBLE = DataType.DOUBLE,
+            INT = DataType.INT,
+            SHORT = DataType.SHORT,
+            FLOAT = DataType.FLOAT,
+        }
+
+        public enum EXT_shared_texture_palette : uint
+        {
+            SHARED_TEXTURE_PALETTE_EXT = 0x81FB,
+        }
+
+        public enum ATI_vertex_array_object : uint
+        {
+            ARRAY_OBJECT_BUFFER_ATI = 0x8766,
+            PRESERVE_ATI = 0x8762,
+            DISCARD_ATI = 0x8763,
+            STATIC_ATI = 0x8760,
+            ARRAY_OBJECT_OFFSET_ATI = 0x8767,
+            OBJECT_BUFFER_SIZE_ATI = 0x8764,
+            OBJECT_BUFFER_USAGE_ATI = 0x8765,
+            DYNAMIC_ATI = 0x8761,
+        }
+
+        public enum PixelTexGenParameterNameSGIS : uint
+        {
+            PIXEL_FRAGMENT_RGB_SOURCE_SGIS = SGIS_pixel_texture.PIXEL_FRAGMENT_RGB_SOURCE_SGIS,
+            PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = SGIS_pixel_texture.PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS,
+        }
+
+        public enum EXT_blend_equation_separate : uint
+        {
+            BLEND_EQUATION_RGB_EXT = ARB_imaging.BLEND_EQUATION,
+            BLEND_EQUATION_ALPHA_EXT = 0x883D,
+        }
+
+        public enum PixelStoreResampleMode : uint
+        {
+            RESAMPLE_DECIMATE_SGIX = SGIX_resample.RESAMPLE_DECIMATE_SGIX,
+            RESAMPLE_REPLICATE_SGIX = SGIX_resample.RESAMPLE_REPLICATE_SGIX,
+            RESAMPLE_ZERO_FILL_SGIX = SGIX_resample.RESAMPLE_ZERO_FILL_SGIX,
+        }
+
+        public enum SGIX_fragment_lighting : uint
+        {
+            FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402,
+            FRAGMENT_LIGHT1_SGIX = 0x840D,
+            LIGHT_ENV_MODE_SGIX = 0x8407,
+            FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408,
+            CURRENT_RASTER_NORMAL_SGIX = 0x8406,
+            FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403,
+            FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B,
+            MAX_FRAGMENT_LIGHTS_SGIX = 0x8404,
+            FRAGMENT_LIGHT4_SGIX = 0x8410,
+            FRAGMENT_LIGHT5_SGIX = 0x8411,
+            FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A,
+            FRAGMENT_LIGHTING_SGIX = 0x8400,
+            FRAGMENT_LIGHT6_SGIX = 0x8412,
+            MAX_ACTIVE_LIGHTS_SGIX = 0x8405,
+            FRAGMENT_LIGHT2_SGIX = 0x840E,
+            FRAGMENT_LIGHT0_SGIX = 0x840C,
+            FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401,
+            FRAGMENT_LIGHT3_SGIX = 0x840F,
+            FRAGMENT_LIGHT7_SGIX = 0x8413,
+            FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409,
+        }
+
+        public enum NV_depth_clamp : uint
+        {
+            DEPTH_CLAMP_NV = 0x864F,
+        }
+
+        public enum EXT_blend_subtract : uint
+        {
+            FUNC_SUBTRACT = 0x800A,
+            FUNC_REVERSE_SUBTRACT = 0x800B,
+            FUNC_REVERSE_SUBTRACT_EXT = 0x800B,
+            FUNC_SUBTRACT_EXT = 0x800A,
+        }
+
+        public enum ARB_vertex_program : uint
+        {
+            VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A,
+            MATRIX9_ARB = 0x88C9,
+            MATRIX24_ARB = 0x88D8,
+            MATRIX25_ARB = 0x88D9,
+            TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7,
+            MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB,
+            MATRIX22_ARB = 0x88D6,
+            MAX_PROGRAM_MATRICES_ARB = 0x862F,
+            PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA,
+            PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2,
+            MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3,
+            PROGRAM_FORMAT_ARB = 0x8876,
+            MATRIX8_ARB = 0x88C8,
+            MAX_PROGRAM_PARAMETERS_ARB = 0x88A9,
+            MATRIX13_ARB = 0x88CD,
+            MATRIX31_ARB = 0x88DF,
+            MATRIX6_ARB = 0x88C6,
+            MATRIX27_ARB = 0x88DB,
+            MATRIX7_ARB = 0x88C7,
+            PROGRAM_ERROR_STRING_ARB = 0x8874,
+            PROGRAM_PARAMETERS_ARB = 0x88A8,
+            PROGRAM_BINDING_ARB = 0x8677,
+            VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642,
+            PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6,
+            CURRENT_VERTEX_ATTRIB_ARB = 0x8626,
+            MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4,
+            MATRIX12_ARB = 0x88CC,
+            PROGRAM_STRING_ARB = 0x8628,
+            PROGRAM_INSTRUCTIONS_ARB = 0x88A0,
+            MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5,
+            VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623,
+            MATRIX26_ARB = 0x88DA,
+            MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3,
+            MATRIX4_ARB = 0x88C4,
+            CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640,
+            VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643,
+            VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625,
+            PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0,
+            MATRIX2_ARB = 0x88C2,
+            MATRIX5_ARB = 0x88C5,
+            PROGRAM_ATTRIBS_ARB = 0x88AC,
+            MATRIX14_ARB = 0x88CE,
+            VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624,
+            MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1,
+            MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E,
+            MATRIX3_ARB = 0x88C3,
+            PROGRAM_TEMPORARIES_ARB = 0x88A4,
+            MATRIX28_ARB = 0x88DC,
+            MATRIX29_ARB = 0x88DD,
+            MAX_VERTEX_ATTRIBS_ARB = 0x8869,
+            MATRIX20_ARB = 0x88D4,
+            MATRIX21_ARB = 0x88D5,
+            MAX_PROGRAM_ATTRIBS_ARB = 0x88AD,
+            PROGRAM_ERROR_POSITION_ARB = 0x864B,
+            PROGRAM_FORMAT_ASCII_ARB = 0x8875,
+            MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5,
+            PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2,
+            VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622,
+            VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645,
+            MATRIX30_ARB = 0x88DE,
+            MATRIX15_ARB = 0x88CF,
+            VERTEX_PROGRAM_ARB = 0x8620,
+            MATRIX0_ARB = 0x88C0,
+            MATRIX17_ARB = 0x88D1,
+            PROGRAM_LENGTH_ARB = 0x8627,
+            COLOR_SUM_ARB = 0x8458,
+            MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF,
+            MATRIX1_ARB = 0x88C1,
+            PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6,
+            MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1,
+            MATRIX23_ARB = 0x88D7,
+            MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7,
+            PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE,
+            CURRENT_MATRIX_ARB = 0x8641,
+            MATRIX18_ARB = 0x88D2,
+            MATRIX19_ARB = 0x88D3,
+            MATRIX10_ARB = 0x88CA,
+            MATRIX11_ARB = 0x88CB,
+            MATRIX16_ARB = 0x88D0,
+        }
+
+        public enum SUN_vertex : uint
+        {
+        }
+
+        public enum EXT_secondary_color : uint
+        {
+            SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A,
+            SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D,
+            SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C,
+            SECONDARY_COLOR_ARRAY_EXT = 0x845E,
+            COLOR_SUM_EXT = 0x8458,
+            SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B,
+            CURRENT_SECONDARY_COLOR_EXT = 0x8459,
+        }
+
+        public enum SGIX_scalebias_hint : uint
+        {
+            SCALEBIAS_HINT_SGIX = 0x8322,
+        }
+
+        public enum ListNameType : uint
+        {
+            UNSIGNED_INT = DataType.UNSIGNED_INT,
+            _4_BYTES = DataType._4_BYTES,
+            FLOAT = DataType.FLOAT,
+            UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
+            SHORT = DataType.SHORT,
+            BYTE = DataType.BYTE,
+            _3_BYTES = DataType._3_BYTES,
+            INT = DataType.INT,
+            UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
+            _2_BYTES = DataType._2_BYTES,
+        }
+
+        public enum RenderingMode : uint
+        {
+            SELECT = 0x1C02,
+            FEEDBACK = 0x1C01,
+            RENDER = 0x1C00,
+        }
+
+        public enum EXT_texture_lod_bias : uint
+        {
+            MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD,
+            TEXTURE_FILTER_CONTROL_EXT = 0x8500,
+            TEXTURE_LOD_BIAS_EXT = 0x8501,
+        }
+
+        public enum ARB_depth_texture : uint
+        {
+            DEPTH_TEXTURE_MODE_ARB = 0x884B,
+            DEPTH_COMPONENT16_ARB = 0x81A5,
+            DEPTH_COMPONENT24_ARB = 0x81A6,
+            DEPTH_COMPONENT32_ARB = 0x81A7,
+            TEXTURE_DEPTH_SIZE_ARB = 0x884A,
+        }
+
+        public enum ARB_multisample : uint
+        {
+            SAMPLE_COVERAGE_VALUE_ARB = 0x80AA,
+            SAMPLES_ARB = 0x80A9,
+            SAMPLE_BUFFERS = 0x80A8,
+            SAMPLE_COVERAGE = 0x80A0,
+            MULTISAMPLE_ARB = 0x809D,
+            SAMPLE_ALPHA_TO_COVERAGE = 0x809E,
+            SAMPLE_BUFFERS_ARB = 0x80A8,
+            SAMPLE_COVERAGE_ARB = 0x80A0,
+            SAMPLE_COVERAGE_INVERT_ARB = 0x80AB,
+            SAMPLE_COVERAGE_INVERT = 0x80AB,
+            MULTISAMPLE = 0x809D,
+            SAMPLE_ALPHA_TO_ONE_ARB = 0x809F,
+            SAMPLE_ALPHA_TO_ONE = 0x809F,
+            SAMPLES = 0x80A9,
+            SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E,
+            MULTISAMPLE_BIT_ARB = 0x20000000,
+            SAMPLE_COVERAGE_VALUE = 0x80AA,
+        }
+
+        public enum ConvolutionTargetEXT : uint
+        {
+            CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
+            CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
+        }
+
+        public enum EXT_stencil_wrap : uint
+        {
+            DECR_WRAP_EXT = 0x8508,
+            INCR_WRAP_EXT = 0x8507,
+        }
+
+        public enum SGIS_fog_function : uint
+        {
+            FOG_FUNC_POINTS_SGIS = 0x812B,
+            MAX_FOG_FUNC_POINTS_SGIS = 0x812C,
+            FOG_FUNC_SGIS = 0x812A,
+        }
+
+        public enum SGIX_convolution_accuracy : uint
+        {
+            CONVOLUTION_HINT_SGIX = 0x8316,
+        }
+
+        public enum TextureGenMode : uint
+        {
+            EYE_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_LINE_SGIS,
+            EYE_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_POINT_SGIS,
+            OBJECT_LINEAR = 0x2401,
+            OBJECT_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_LINE_SGIS,
+            OBJECT_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_POINT_SGIS,
+            EYE_LINEAR = 0x2400,
+            SPHERE_MAP = 0x2402,
+        }
+
+        public enum APPLE_client_storage : uint
+        {
+            UNPACK_CLIENT_STORAGE_APPLE = 0x85B2,
+        }
+
+        public enum SUN_slice_accum : uint
+        {
+            SLICE_ACCUM_SUN = 0x85CC,
+        }
+
+        public enum SGIX_polynomial_ffd : uint
+        {
+            MAX_DEFORMATION_ORDER_SGIX = 0x8197,
+            GEOMETRY_DEFORMATION_SGIX = 0x8194,
+            TEXTURE_DEFORMATION_SGIX = 0x8195,
+            DEFORMATIONS_MASK_SGIX = 0x8196,
+        }
+
+        public enum ARB_point_parameters : uint
+        {
+            POINT_DISTANCE_ATTENUATION_ARB = 0x8129,
+            POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128,
+            POINT_SIZE_MIN_ARB = 0x8126,
+            POINT_SIZE_MAX_ARB = 0x8127,
+        }
+
+        public enum ARB_window_pos : uint
+        {
+        }
+
+        public enum ATI_map_object_buffer : uint
+        {
+        }
+
+        public enum OES_read_format : uint
+        {
+            IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A,
+            IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B,
+        }
+
+        public enum GetPName : uint
+        {
+            FRAGMENT_COLOR_MATERIAL_FACE_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_FACE_SGIX,
+            POLYGON_MODE = 0x0B40,
+            STENCIL_FUNC = 0x0B92,
+            FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX,
+            HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
+            CULL_FACE_MODE = 0x0B45,
+            PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX,
+            POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_RANGE_SGIX,
+            CURRENT_RASTER_DISTANCE = 0x0B09,
+            PIXEL_TILE_BEST_ALIGNMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_BEST_ALIGNMENT_SGIX,
+            POINT_SIZE = 0x0B11,
+            MODELVIEW_STACK_DEPTH = 0x0BA3,
+            TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
+            SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS,
+            PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
+            ALPHA_BIAS = 0x0D1D,
+            MAP1_GRID_DOMAIN = 0x0DD0,
+            PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT,
+            MAP2_VERTEX_4 = 0x0DB8,
+            POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT,
+            MAP2_VERTEX_3 = 0x0DB7,
+            DEPTH_RANGE = 0x0B70,
+            POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI,
+            MAX_ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_DRAW_PIXELS_SGIX,
+            PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
+            UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX,
+            CURRENT_RASTER_INDEX = 0x0B05,
+            LIGHT3 = LightName.LIGHT3,
+            UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT,
+            INDEX_ARRAY_COUNT_EXT = EXT_vertex_array.INDEX_ARRAY_COUNT_EXT,
+            LIST_INDEX = 0x0B33,
+            FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX,
+            DEPTH_CLEAR_VALUE = 0x0B73,
+            CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1,
+            DETAIL_TEXTURE_2D_BINDING_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_BINDING_SGIS,
+            STENCIL_VALUE_MASK = 0x0B93,
+            GREEN_BITS = 0x0D53,
+            COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.COLOR_MATRIX_STACK_DEPTH_SGI,
+            POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT,
+            FOG_END = 0x0B64,
+            CLIP_PLANE0 = ClipPlaneName.CLIP_PLANE0,
+            MAX_MODELVIEW_STACK_DEPTH = 0x0D36,
+            LINE_SMOOTH_HINT = 0x0C52,
+            POLYGON_OFFSET_FACTOR = 0x8038,
+            MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS,
+            FOG_MODE = 0x0B65,
+            POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT,
+            PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS,
+            LIST_BASE = 0x0B32,
+            TEXTURE_STACK_DEPTH = 0x0BA5,
+            SCISSOR_TEST = 0x0C11,
+            CURRENT_NORMAL = 0x0B02,
+            CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX,
+            PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
+            INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX,
+            EDGE_FLAG_ARRAY = 0x8079,
+            MAP1_COLOR_4 = 0x0D90,
+            TEXTURE_MATRIX = 0x0BA8,
+            LIGHT4 = LightName.LIGHT4,
+            MAX_3D_TEXTURE_SIZE_EXT = EXT_texture3D.MAX_3D_TEXTURE_SIZE_EXT,
+            PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
+            SELECTION_BUFFER_SIZE = 0x0DF4,
+            MAP2_TEXTURE_COORD_3 = 0x0DB5,
+            SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX,
+            ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX,
+            MAX_FRAGMENT_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_FRAGMENT_LIGHTS_SGIX,
+            PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX,
+            LIGHT_MODEL_AMBIENT = 0x0B53,
+            PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX,
+            ZOOM_X = 0x0D16,
+            PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS,
+            CLIP_PLANE3 = ClipPlaneName.CLIP_PLANE3,
+            COLOR_MATERIAL_FACE = 0x0B55,
+            SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT,
+            SMOOTH_POINT_SIZE_RANGE = VERSION_1_2.SMOOTH_POINT_SIZE_RANGE,
+            ATTRIB_STACK_DEPTH = 0x0BB0,
+            MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B,
+            MAP1_GRID_SEGMENTS = 0x0DD1,
+            FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
+            BLUE_SCALE = 0x0D1A,
+            POINT_SMOOTH = 0x0B10,
+            MAX_PROJECTION_STACK_DEPTH = 0x0D38,
+            INDEX_WRITEMASK = 0x0C21,
+            TEXTURE_BINDING_3D = 0x806A,
+            MAP1_TEXTURE_COORD_4 = 0x0D96,
+            TEXTURE_BINDING_1D = 0x8068,
+            UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT,
+            GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS,
+            POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI,
+            NORMAL_ARRAY_STRIDE = 0x807F,
+            FOG = 0x0B60,
+            CURRENT_RASTER_POSITION_VALID = 0x0B08,
+            COLOR_ARRAY_TYPE = 0x8082,
+            POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI,
+            CLIP_PLANE5 = ClipPlaneName.CLIP_PLANE5,
+            PACK_SKIP_PIXELS = 0x0D04,
+            ALPHA_SCALE = 0x0D1C,
+            SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS,
+            STEREO = 0x0C33,
+            READ_BUFFER = 0x0C02,
+            MAX_4D_TEXTURE_SIZE_SGIS = SGIS_texture4D.MAX_4D_TEXTURE_SIZE_SGIS,
+            RENDER_MODE = 0x0C40,
+            POINT_SIZE_RANGE = 0x0B12,
+            LIST_MODE = 0x0B30,
+            FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX,
+            LIGHTING = 0x0B50,
+            ACCUM_CLEAR_VALUE = 0x0B80,
+            UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX,
+            TEXTURE_GEN_Q = 0x0C63,
+            MAP2_TEXTURE_COORD_2 = 0x0DB4,
+            TEXTURE_GEN_T = 0x0C61,
+            ALIASED_LINE_WIDTH_RANGE = VERSION_1_2.ALIASED_LINE_WIDTH_RANGE,
+            RED_BITS = 0x0D52,
+            COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
+            SCISSOR_BOX = 0x0C10,
+            PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX,
+            INDEX_ARRAY_TYPE = 0x8085,
+            LIGHT6 = LightName.LIGHT6,
+            MAX_COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.MAX_COLOR_MATRIX_STACK_DEPTH_SGI,
+            SAMPLES_SGIS = SGIS_multisample.SAMPLES_SGIS,
+            BLEND = 0x0BE2,
+            STENCIL_CLEAR_VALUE = 0x0B91,
+            FEEDBACK_BUFFER_SIZE = 0x0DF1,
+            SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
+            LINE_STIPPLE_REPEAT = 0x0B26,
+            INDEX_MODE = 0x0C30,
+            TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
+            SMOOTH_LINE_WIDTH_RANGE = VERSION_1_2.SMOOTH_LINE_WIDTH_RANGE,
+            STENCIL_REF = 0x0B97,
+            SMOOTH_POINT_SIZE_GRANULARITY = VERSION_1_2.SMOOTH_POINT_SIZE_GRANULARITY,
+            BLUE_BITS = 0x0D54,
+            FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX,
+            COLOR_LOGIC_OP = 0x0BF2,
+            POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
+            BLEND_COLOR_EXT = EXT_blend_color.BLEND_COLOR_EXT,
+            PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS,
+            MAX_FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.MAX_FRAMEZOOM_FACTOR_SGIX,
+            MATRIX_MODE = 0x0BA0,
+            DEPTH_FUNC = 0x0B74,
+            POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI,
+            PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX,
+            FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX,
+            ACCUM_RED_BITS = 0x0D58,
+            POLYGON_OFFSET_UNITS = 0x2A00,
+            TEXTURE_2D = 0x0DE1,
+            EDGE_FLAG_ARRAY_COUNT_EXT = EXT_vertex_array.EDGE_FLAG_ARRAY_COUNT_EXT,
+            TEXTURE_COORD_ARRAY_TYPE = 0x8089,
+            CURRENT_INDEX = 0x0B01,
+            PACK_SWAP_BYTES = 0x0D00,
+            INDEX_ARRAY = 0x8077,
+            GREEN_BIAS = 0x0D19,
+            SAMPLE_MASK_INVERT_SGIS = SGIS_multisample.SAMPLE_MASK_INVERT_SGIS,
+            AUTO_NORMAL = 0x0D80,
+            POINT_SIZE_GRANULARITY = 0x0B13,
+            POLYGON_SMOOTH = 0x0B41,
+            FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX,
+            ALPHA_BITS = 0x0D55,
+            UNPACK_ALIGNMENT = 0x0CF5,
+            SAMPLE_PATTERN_SGIS = SGIS_multisample.SAMPLE_PATTERN_SGIS,
+            INDEX_ARRAY_STRIDE = 0x8086,
+            POLYGON_OFFSET_BIAS_EXT = EXT_polygon_offset.POLYGON_OFFSET_BIAS_EXT,
+            RED_SCALE = 0x0D14,
+            UNPACK_SKIP_ROWS = 0x0CF3,
+            INDEX_LOGIC_OP = 0x0BF1,
+            MAP2_COLOR_4 = 0x0DB0,
+            VERTEX_ARRAY_COUNT_EXT = EXT_vertex_array.VERTEX_ARRAY_COUNT_EXT,
+            MAP1_NORMAL = 0x0D92,
+            MAP1_TEXTURE_COORD_2 = 0x0D94,
+            PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
+            ACCUM_BLUE_BITS = 0x0D5A,
+            ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX,
+            COLOR_WRITEMASK = 0x0C23,
+            NAME_STACK_DEPTH = 0x0D70,
+            POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT,
+            MAX_NAME_STACK_DEPTH = 0x0D37,
+            CLIP_PLANE4 = ClipPlaneName.CLIP_PLANE4,
+            FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX,
+            PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
+            PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT,
+            LIGHT0 = LightName.LIGHT0,
+            PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
+            FOG_HINT = 0x0C54,
+            PROJECTION_STACK_DEPTH = 0x0BA4,
+            PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX,
+            RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT,
+            MAP2_GRID_DOMAIN = 0x0DD2,
+            ALPHA_TEST_FUNC = 0x0BC1,
+            MAX_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_DEPTH_SGIX,
+            UNPACK_SKIP_PIXELS = 0x0CF4,
+            NORMAL_ARRAY_TYPE = 0x807E,
+            FOG_FUNC_POINTS_SGIS = SGIS_fog_function.FOG_FUNC_POINTS_SGIS,
+            GREEN_SCALE = 0x0D18,
+            PACK_ROW_LENGTH = 0x0D02,
+            CURRENT_COLOR = 0x0B00,
+            MAX_FOG_FUNC_POINTS_SGIS = SGIS_fog_function.MAX_FOG_FUNC_POINTS_SGIS,
+            POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT,
+            COLOR_ARRAY_SIZE = 0x8081,
+            MAP2_TEXTURE_COORD_4 = 0x0DB6,
+            COLOR_MATERIAL_PARAMETER = 0x0B56,
+            FOG_DENSITY = 0x0B62,
+            FOG_START = 0x0B63,
+            FRONT_FACE = 0x0B46,
+            POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI,
+            SPRITE_AXIS_SGIX = SGIX_sprite.SPRITE_AXIS_SGIX,
+            UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS,
+            MAP1_VERTEX_4 = 0x0D98,
+            ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX,
+            LIGHT5 = LightName.LIGHT5,
+            MAP1_VERTEX_3 = 0x0D97,
+            AUX_BUFFERS = 0x0C00,
+            UNPACK_LSB_FIRST = 0x0CF1,
+            VERTEX_ARRAY_SIZE = 0x807A,
+            COLOR_MATERIAL = 0x0B57,
+            MAP1_TEXTURE_COORD_3 = 0x0D95,
+            LINE_STIPPLE_PATTERN = 0x0B25,
+            PERSPECTIVE_CORRECTION_HINT = 0x0C50,
+            MAX_ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.MAX_ASYNC_TEX_IMAGE_SGIX,
+            PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
+            UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT,
+            SPRITE_TRANSLATION_SGIX = SGIX_sprite.SPRITE_TRANSLATION_SGIX,
+            PIXEL_TILE_CACHE_INCREMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_INCREMENT_SGIX,
+            SAMPLE_MASK_VALUE_SGIS = SGIS_multisample.SAMPLE_MASK_VALUE_SGIS,
+            LOGIC_OP = 0x0BF1,
+            PACK_LSB_FIRST = 0x0D01,
+            LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX,
+            MAP2_INDEX = 0x0DB1,
+            UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS,
+            FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX,
+            COLOR_CLEAR_VALUE = 0x0C22,
+            MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX,
+            PROJECTION_MATRIX = 0x0BA7,
+            POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT,
+            ACCUM_ALPHA_BITS = 0x0D5B,
+            DEPTH_TEST = 0x0B71,
+            LINE_STIPPLE = 0x0B24,
+            MAX_TEXTURE_STACK_DEPTH = 0x0D39,
+            LINE_WIDTH = 0x0B21,
+            MAX_LIGHTS = 0x0D31,
+            STENCIL_PASS_DEPTH_PASS = 0x0B96,
+            VERTEX_ARRAY_STRIDE = 0x807C,
+            PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX,
+            PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT,
+            EDGE_FLAG = 0x0B43,
+            POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT,
+            TEXTURE_1D = 0x0DE0,
+            POINT_SMOOTH_HINT = 0x0C51,
+            TEXTURE_GEN_S = 0x0C60,
+            TEXTURE_GEN_R = 0x0C62,
+            POINT_FADE_THRESHOLD_SIZE_SGIS = SGIS_point_parameters.POINT_FADE_THRESHOLD_SIZE_SGIS,
+            PACK_ALIGNMENT = 0x0D05,
+            DOUBLEBUFFER = 0x0C32,
+            REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX,
+            COLOR_ARRAY_COUNT_EXT = EXT_vertex_array.COLOR_ARRAY_COUNT_EXT,
+            PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX,
+            MAX_ACTIVE_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_ACTIVE_LIGHTS_SGIX,
+            BLEND_SRC = 0x0BE1,
+            DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS,
+            PACK_SKIP_ROWS = 0x0D03,
+            FOG_COLOR = 0x0B66,
+            LINE_SMOOTH = 0x0B20,
+            MAX_VIEWPORT_DIMS = 0x0D3A,
+            POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI,
+            COLOR_ARRAY = 0x8076,
+            MAX_TEXTURE_SIZE = 0x0D33,
+            FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX,
+            LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL,
+            CLIP_PLANE1 = ClipPlaneName.CLIP_PLANE1,
+            PIXEL_TEX_GEN_MODE_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_MODE_SGIX,
+            VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX,
+            LIGHT7 = LightName.LIGHT7,
+            COLOR_MATRIX_SGI = SGI_color_matrix.COLOR_MATRIX_SGI,
+            FEEDBACK_BUFFER_TYPE = 0x0DF2,
+            RED_BIAS = 0x0D15,
+            FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.FRAMEZOOM_FACTOR_SGIX,
+            LINE_WIDTH_GRANULARITY = 0x0B23,
+            MODELVIEW_MATRIX = 0x0BA6,
+            MAX_ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.MAX_ASYNC_HISTOGRAM_SGIX,
+            CULL_FACE = 0x0B44,
+            DITHER = 0x0BD0,
+            SMOOTH_LINE_WIDTH_GRANULARITY = VERSION_1_2.SMOOTH_LINE_WIDTH_GRANULARITY,
+            CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
+            POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI,
+            STENCIL_WRITEMASK = 0x0B98,
+            SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS,
+            STENCIL_FAIL = 0x0B94,
+            PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
+            BLUE_BIAS = 0x0D1B,
+            SHADE_MODEL = 0x0B54,
+            ASYNC_MARKER_SGIX = SGIX_async.ASYNC_MARKER_SGIX,
+            INDEX_BITS = 0x0D51,
+            ACCUM_GREEN_BITS = 0x0D59,
+            FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX,
+            SPRITE_MODE_SGIX = SGIX_sprite.SPRITE_MODE_SGIX,
+            PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX,
+            UNPACK_ROW_LENGTH = 0x0CF2,
+            CURRENT_RASTER_COLOR = 0x0B04,
+            TEXTURE_COORD_ARRAY_COUNT_EXT = EXT_vertex_array.TEXTURE_COORD_ARRAY_COUNT_EXT,
+            LOGIC_OP_MODE = 0x0BF0,
+            DEFORMATIONS_MASK_SGIX = SGIX_polynomial_ffd.DEFORMATIONS_MASK_SGIX,
+            POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_SGIS,
+            CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX,
+            CURRENT_RASTER_POSITION = 0x0B07,
+            SAMPLE_BUFFERS_SGIS = SGIS_multisample.SAMPLE_BUFFERS_SGIS,
+            DEPTH_WRITEMASK = 0x0B72,
+            DRAW_BUFFER = 0x0C01,
+            COLOR_ARRAY_STRIDE = 0x8083,
+            DEPTH_SCALE = 0x0D1E,
+            ALPHA_TEST = 0x0BC0,
+            NORMALIZE = 0x0BA1,
+            IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX,
+            MINMAX_EXT = EXT_histogram.MINMAX_EXT,
+            TEXTURE_BINDING_2D = 0x8069,
+            MAX_ATTRIB_STACK_DEPTH = 0x0D35,
+            LIGHT2 = LightName.LIGHT2,
+            TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
+            CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
+            MAP1_TEXTURE_COORD_1 = 0x0D93,
+            VIEWPORT = 0x0BA2,
+            INSTRUMENT_MEASUREMENTS_SGIX = SGIX_instruments.INSTRUMENT_MEASUREMENTS_SGIX,
+            POLYGON_SMOOTH_HINT = 0x0C53,
+            LIGHT_MODEL_TWO_SIDE = 0x0B52,
+            INDEX_OFFSET = 0x0D13,
+            MAP_COLOR = 0x0D10,
+            FOG_INDEX = 0x0B61,
+            ZOOM_Y = 0x0D17,
+            CLIP_PLANE2 = ClipPlaneName.CLIP_PLANE2,
+            STENCIL_TEST = 0x0B90,
+            ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX,
+            MAX_EVAL_ORDER = 0x0D30,
+            MAP2_NORMAL = 0x0DB2,
+            STENCIL_PASS_DEPTH_FAIL = 0x0B95,
+            VERTEX_ARRAY = 0x8074,
+            ALIASED_POINT_SIZE_RANGE = VERSION_1_2.ALIASED_POINT_SIZE_RANGE,
+            REFERENCE_PLANE_EQUATION_SGIX = SGIX_reference_plane.REFERENCE_PLANE_EQUATION_SGIX,
+            NORMAL_ARRAY = 0x8075,
+            UNPACK_SWAP_BYTES = 0x0CF0,
+            INDEX_CLEAR_VALUE = 0x0C20,
+            TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
+            LIGHT1 = LightName.LIGHT1,
+            CURRENT_TEXTURE_COORDS = 0x0B03,
+            MAP2_TEXTURE_COORD_1 = 0x0DB3,
+            TEXTURE_COORD_ARRAY = 0x8078,
+            BLEND_EQUATION_EXT = EXT_blend_minmax.BLEND_EQUATION_EXT,
+            POLYGON_STIPPLE = 0x0B42,
+            VERTEX_ARRAY_TYPE = 0x807B,
+            MAP1_INDEX = 0x0D91,
+            NORMAL_ARRAY_COUNT_EXT = EXT_vertex_array.NORMAL_ARRAY_COUNT_EXT,
+            CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
+            MAX_LIST_NESTING = 0x0B31,
+            STENCIL_BITS = 0x0D57,
+            SUBPIXEL_BITS = 0x0D50,
+            POLYGON_OFFSET_FILL = 0x8037,
+            LINE_WIDTH_RANGE = 0x0B22,
+            POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_RANGE_SGIX,
+            VERTEX_PRECLIP_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_SGIX,
+            POLYGON_OFFSET_POINT = 0x2A01,
+            ALPHA_TEST_REF = 0x0BC2,
+            RGBA_MODE = 0x0C31,
+            EDGE_FLAG_ARRAY_STRIDE = 0x808C,
+            LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
+            INDEX_SHIFT = 0x0D12,
+            MAP_STENCIL = 0x0D11,
+            TEXTURE_COORD_ARRAY_SIZE = 0x8088,
+            POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI,
+            TEXTURE_3D_BINDING_EXT = EXT_texture_object.TEXTURE_3D_BINDING_EXT,
+            PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
+            POLYGON_OFFSET_LINE = 0x2A02,
+            MAX_PIXEL_MAP_TABLE = 0x0D34,
+            POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI,
+            BLEND_DST = 0x0BE0,
+            TEXTURE_4D_BINDING_SGIS = SGIS_texture4D.TEXTURE_4D_BINDING_SGIS,
+            DEPTH_BIAS = 0x0D1F,
+            POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT,
+            MAP2_GRID_SEGMENTS = 0x0DD3,
+            MAX_CLIP_PLANES = 0x0D32,
+            MAX_ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_READ_PIXELS_SGIX,
+            DEPTH_BITS = 0x0D56,
+            POINT_SIZE_MAX_SGIS = SGIS_point_parameters.POINT_SIZE_MAX_SGIS,
+        }
+
+        public enum NV_packed_depth_stencil : uint
+        {
+            DEPTH_STENCIL_NV = 0x84F9,
+            UNSIGNED_INT_24_8_NV = 0x84FA,
+        }
+
+        public enum ATI_text_fragment_shader : uint
+        {
+            TEXT_FRAGMENT_SHADER_ATI = 0x8200,
+        }
+
+        public enum SGIS_texture_color_mask : uint
+        {
+            TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF,
+        }
+
+        public enum SGIX_flush_raster : uint
+        {
+        }
+
+        public enum SGIX_ycrcb_subsample : uint
+        {
+            PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3,
+            PACK_SUBSAMPLE_RATE_SGIX = 0x85A0,
+            PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2,
+            PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4,
+            UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1,
+        }
+
+        public enum SGIX_texture_lod_bias : uint
+        {
+            TEXTURE_LOD_BIAS_R_SGIX = 0x8190,
+            TEXTURE_LOD_BIAS_S_SGIX = 0x818E,
+            TEXTURE_LOD_BIAS_T_SGIX = 0x818F,
+        }
+
+        public enum TextureEnvMode : uint
+        {
+            REPLACE_EXT = EXT_texture.REPLACE_EXT,
+            MODULATE = 0x2100,
+            ADD = AccumOp.ADD,
+            DECAL = 0x2101,
+            BLEND = GetPName.BLEND,
+            TEXTURE_ENV_BIAS_SGIX = SGIX_texture_add_env.TEXTURE_ENV_BIAS_SGIX,
+        }
+
+        public enum EXT_texture_cube_map : uint
+        {
+            TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516,
+            TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518,
+            TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517,
+            TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A,
+            TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514,
+            REFLECTION_MAP_EXT = 0x8512,
+            TEXTURE_CUBE_MAP_EXT = 0x8513,
+            MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C,
+            TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519,
+            PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B,
+            TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515,
+            NORMAL_MAP_EXT = 0x8511,
+        }
+
+        public enum IndexPointerType : uint
+        {
+            DOUBLE = DataType.DOUBLE,
+            INT = DataType.INT,
+            SHORT = DataType.SHORT,
+            FLOAT = DataType.FLOAT,
+        }
+
+        public enum FogParameter : uint
+        {
+            FOG_END = GetPName.FOG_END,
+            FOG_COLOR = GetPName.FOG_COLOR,
+            FOG_DENSITY = GetPName.FOG_DENSITY,
+            FOG_START = GetPName.FOG_START,
+            FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX,
+            FOG_INDEX = GetPName.FOG_INDEX,
+            FOG_MODE = GetPName.FOG_MODE,
+        }
+
+        public enum SGIS_sharpen_texture : uint
+        {
+            LINEAR_SHARPEN_SGIS = 0x80AD,
+            LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE,
+            LINEAR_SHARPEN_COLOR_SGIS = 0x80AF,
+            SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0,
+        }
+
+        public enum AlphaFunction : uint
+        {
+            NEVER = 0x0200,
+            GEQUAL = 0x0206,
+            GREATER = 0x0204,
+            ALWAYS = 0x0207,
+            LEQUAL = 0x0203,
+            NOTEQUAL = 0x0205,
+            EQUAL = 0x0202,
+            LESS = 0x0201,
+        }
+
+        public enum NV_register_combiners2 : uint
+        {
+            PER_STAGE_CONSTANTS_NV = 0x8535,
+        }
+
+        public enum ARB_texture_env_crossbar : uint
+        {
+        }
+
+        public enum NV_texture_shader2 : uint
+        {
+            DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF,
+        }
+
+        public enum ATI_texture_env_combine3 : uint
+        {
+            MODULATE_ADD_ATI = 0x8744,
+            MODULATE_SIGNED_ADD_ATI = 0x8745,
+            MODULATE_SUBTRACT_ATI = 0x8746,
+        }
+
+        public enum EXT_misc_attribute : uint
+        {
+        }
+
+        public enum IBM_multimode_draw_arrays : uint
+        {
+        }
+
+        public enum SGI_color_matrix : uint
+        {
+            POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8,
+            POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA,
+            COLOR_MATRIX_SGI = 0x80B1,
+            POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6,
+            POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9,
+            POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6,
+            POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB,
+            COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2,
+            POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9,
+            POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7,
+            POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5,
+            POST_COLOR_MATRIX_RED_BIAS = 0x80B8,
+            MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3,
+            POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7,
+            COLOR_MATRIX_STACK_DEPTH = 0x80B2,
+            POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA,
+            COLOR_MATRIX = 0x80B1,
+            POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5,
+            POST_COLOR_MATRIX_RED_SCALE = 0x80B4,
+            MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3,
+            POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB,
+            POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4,
+        }
+
+        public enum SamplePatternSGIS : uint
+        {
+            _4PASS_0_SGIS = SGIS_multisample._4PASS_0_SGIS,
+            _4PASS_1_SGIS = SGIS_multisample._4PASS_1_SGIS,
+            _1PASS_SGIS = SGIS_multisample._1PASS_SGIS,
+            _2PASS_0_SGIS = SGIS_multisample._2PASS_0_SGIS,
+            _4PASS_2_SGIS = SGIS_multisample._4PASS_2_SGIS,
+            _2PASS_1_SGIS = SGIS_multisample._2PASS_1_SGIS,
+            _4PASS_3_SGIS = SGIS_multisample._4PASS_3_SGIS,
+        }
+
+        public enum SGIS_texture_filter4 : uint
+        {
+            TEXTURE_FILTER4_SIZE_SGIS = 0x8147,
+            FILTER4_SGIS = 0x8146,
+        }
+
+        public enum IBM_vertex_array_lists : uint
+        {
+            INDEX_ARRAY_LIST_IBM = 103073,
+            FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086,
+            SECONDARY_COLOR_ARRAY_LIST_IBM = 103077,
+            NORMAL_ARRAY_LIST_IBM = 103071,
+            COLOR_ARRAY_LIST_STRIDE_IBM = 103082,
+            TEXTURE_COORD_ARRAY_LIST_IBM = 103074,
+            EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085,
+            COLOR_ARRAY_LIST_IBM = 103072,
+            INDEX_ARRAY_LIST_STRIDE_IBM = 103083,
+            EDGE_FLAG_ARRAY_LIST_IBM = 103075,
+            SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087,
+            TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084,
+            FOG_COORDINATE_ARRAY_LIST_IBM = 103076,
+            VERTEX_ARRAY_LIST_IBM = 103070,
+            VERTEX_ARRAY_LIST_STRIDE_IBM = 103080,
+            NORMAL_ARRAY_LIST_STRIDE_IBM = 103081,
+        }
+
+        public enum NV_fence : uint
+        {
+            ALL_COMPLETED_NV = 0x84F2,
+            FENCE_CONDITION_NV = 0x84F4,
+            FENCE_STATUS_NV = 0x84F3,
+        }
+
+        public enum SGIX_async_histogram : uint
+        {
+            MAX_ASYNC_HISTOGRAM_SGIX = 0x832D,
+            ASYNC_HISTOGRAM_SGIX = 0x832C,
+        }
+
+        public enum EXT_gpu_program_parameters : uint
+        {
+        }
+
+        public enum EXT_clip_volume_hint : uint
+        {
+            CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0,
+        }
+
+        public enum EXT_multi_draw_arrays : uint
+        {
+        }
+
+        public enum SUN_mesh_array : uint
+        {
+            TRIANGLE_MESH_SUN = 0x8615,
+            QUAD_MESH_SUN = 0x8614,
+        }
+
+        public enum LightModelColorControl : uint
+        {
+            SEPARATE_SPECULAR_COLOR = VERSION_1_2.SEPARATE_SPECULAR_COLOR,
+            SINGLE_COLOR = VERSION_1_2.SINGLE_COLOR,
+        }
+
+        public enum ATI_element_array : uint
+        {
+            ELEMENT_ARRAY_POINTER_ATI = 0x876A,
+            ELEMENT_ARRAY_ATI = 0x8768,
+            ELEMENT_ARRAY_TYPE_ATI = 0x8769,
+        }
+
+        public enum NV_fragment_program : uint
+        {
+            FRAGMENT_PROGRAM_NV = 0x8870,
+            MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872,
+            PROGRAM_ERROR_STRING_NV = 0x8874,
+            MAX_TEXTURE_COORDS_NV = 0x8871,
+            FRAGMENT_PROGRAM_BINDING_NV = 0x8873,
+            MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868,
+        }
+
+        public enum EXT_subtexture : uint
+        {
+        }
+
+        public enum EXT_draw_range_elements : uint
+        {
+            MAX_ELEMENTS_INDICES_EXT = 0x80E9,
+            MAX_ELEMENTS_VERTICES_EXT = 0x80E8,
+        }
+
+        public enum TextureEnvTarget : uint
+        {
+            TEXTURE_ENV = 0x2300,
+        }
+
+        public enum AccumOp : uint
+        {
+            RETURN = 0x0102,
+            ADD = 0x0104,
+            LOAD = 0x0101,
+            ACCUM = 0x0100,
+            MULT = 0x0103,
+        }
+
+        public enum EXT_fog_coord : uint
+        {
+            FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456,
+            FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455,
+            FOG_COORDINATE_SOURCE_EXT = 0x8450,
+            FOG_COORDINATE_EXT = 0x8451,
+            FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454,
+            FOG_COORDINATE_ARRAY_EXT = 0x8457,
+            CURRENT_FOG_COORDINATE_EXT = 0x8453,
+            FRAGMENT_DEPTH_EXT = 0x8452,
+        }
+
+        public enum ATI_separate_stencil : uint
+        {
+            STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802,
+            STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803,
+            STENCIL_BACK_FAIL_ATI = 0x8801,
+            STENCIL_BACK_FUNC_ATI = 0x8800,
+        }
+
+        public enum OML_subsample : uint
+        {
+            FORMAT_SUBSAMPLE_24_24_OML = 0x8982,
+            FORMAT_SUBSAMPLE_244_244_OML = 0x8983,
+        }
+
+        public enum APPLE_specular_vector : uint
+        {
+            LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0,
+        }
+
+        public enum EXT_abgr : uint
+        {
+            ABGR_EXT = 0x8000,
+        }
+
+        public enum NV_copy_depth_to_color : uint
+        {
+            DEPTH_STENCIL_TO_BGRA_NV = 0x886F,
+            DEPTH_STENCIL_TO_RGBA_NV = 0x886E,
+        }
+
+        public enum NV_vertex_array_range : uint
+        {
+            MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520,
+            VERTEX_ARRAY_RANGE_VALID_NV = 0x851F,
+            VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E,
+            VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521,
+            VERTEX_ARRAY_RANGE_NV = 0x851D,
+        }
+
+        public enum GetColorTableParameterPNameSGI : uint
+        {
+            COLOR_TABLE_BLUE_SIZE_SGI = SGI_color_table.COLOR_TABLE_BLUE_SIZE_SGI,
+            COLOR_TABLE_FORMAT_SGI = SGI_color_table.COLOR_TABLE_FORMAT_SGI,
+            COLOR_TABLE_ALPHA_SIZE_SGI = SGI_color_table.COLOR_TABLE_ALPHA_SIZE_SGI,
+            COLOR_TABLE_INTENSITY_SIZE_SGI = SGI_color_table.COLOR_TABLE_INTENSITY_SIZE_SGI,
+            COLOR_TABLE_GREEN_SIZE_SGI = SGI_color_table.COLOR_TABLE_GREEN_SIZE_SGI,
+            COLOR_TABLE_LUMINANCE_SIZE_SGI = SGI_color_table.COLOR_TABLE_LUMINANCE_SIZE_SGI,
+            COLOR_TABLE_WIDTH_SGI = SGI_color_table.COLOR_TABLE_WIDTH_SGI,
+            COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI,
+            COLOR_TABLE_RED_SIZE_SGI = SGI_color_table.COLOR_TABLE_RED_SIZE_SGI,
+            COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI,
+        }
+
+        public enum SGIX_texture_add_env : uint
+        {
+            TEXTURE_ENV_BIAS_SGIX = 0x80BE,
+        }
+
+        public enum PixelMap : uint
+        {
+            PIXEL_MAP_B_TO_B = GetPixelMap.PIXEL_MAP_B_TO_B,
+            PIXEL_MAP_S_TO_S = GetPixelMap.PIXEL_MAP_S_TO_S,
+            PIXEL_MAP_R_TO_R = GetPixelMap.PIXEL_MAP_R_TO_R,
+            PIXEL_MAP_I_TO_B = GetPixelMap.PIXEL_MAP_I_TO_B,
+            PIXEL_MAP_I_TO_G = GetPixelMap.PIXEL_MAP_I_TO_G,
+            PIXEL_MAP_I_TO_A = GetPixelMap.PIXEL_MAP_I_TO_A,
+            PIXEL_MAP_A_TO_A = GetPixelMap.PIXEL_MAP_A_TO_A,
+            PIXEL_MAP_G_TO_G = GetPixelMap.PIXEL_MAP_G_TO_G,
+            PIXEL_MAP_I_TO_I = GetPixelMap.PIXEL_MAP_I_TO_I,
+            PIXEL_MAP_I_TO_R = GetPixelMap.PIXEL_MAP_I_TO_R,
+        }
+
+        public enum ARB_occlusion_query : uint
+        {
+            QUERY_RESULT_ARB = 0x8866,
+            CURRENT_QUERY_ARB = 0x8865,
+            QUERY_RESULT_AVAILABLE_ARB = 0x8867,
+            SAMPLES_PASSED_ARB = 0x8914,
+            QUERY_COUNTER_BITS_ARB = 0x8864,
+        }
+
+        public enum NV_float_buffer : uint
+        {
+            FLOAT_R16_NV = 0x8884,
+            FLOAT_RG_NV = 0x8881,
+            FLOAT_RGB_NV = 0x8882,
+            FLOAT_R32_NV = 0x8885,
+            FLOAT_RG16_NV = 0x8886,
+            FLOAT_R_NV = 0x8880,
+            FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D,
+            FLOAT_RGB32_NV = 0x8889,
+            FLOAT_RGBA_MODE_NV = 0x888E,
+            TEXTURE_FLOAT_COMPONENTS_NV = 0x888C,
+            FLOAT_RGBA_NV = 0x8883,
+            FLOAT_RGBA16_NV = 0x888A,
+            FLOAT_RGBA32_NV = 0x888B,
+            FLOAT_RGB16_NV = 0x8888,
+            FLOAT_RG32_NV = 0x8887,
+        }
+
+        public enum IBM_cull_vertex : uint
+        {
+            CULL_VERTEX_IBM = 103050,
+        }
+
+        public enum NV_texture_rectangle : uint
+        {
+            TEXTURE_BINDING_RECTANGLE_NV = 0x84F6,
+            PROXY_TEXTURE_RECTANGLE_NV = 0x84F7,
+            MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8,
+            TEXTURE_RECTANGLE_NV = 0x84F5,
+        }
+
+        public enum LightEnvModeSGIX : uint
+        {
+            REPLACE = StencilOp.REPLACE,
+            MODULATE = TextureEnvMode.MODULATE,
+            ADD = AccumOp.ADD,
+        }
+
+        public enum ARB_fragment_program_shadow : uint
+        {
+        }
+
+        public enum SGIX_subsample : uint
+        {
+            PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3,
+            PACK_SUBSAMPLE_RATE_SGIX = 0x85A0,
+            PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2,
+            PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4,
+            UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1,
+        }
+
+        public enum EXT_stencil_two_side : uint
+        {
+            ACTIVE_STENCIL_FACE_EXT = 0x8911,
+            STENCIL_TEST_TWO_SIDE_EXT = 0x8910,
+        }
+
+        public enum SGIX_ir_instrument1 : uint
+        {
+            IR_INSTRUMENT1_SGIX = 0x817F,
+        }
+
+        public enum ARB_transpose_matrix : uint
+        {
+            TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5,
+            TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4,
+            TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6,
+            TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3,
+        }
+
+        public enum PixelType : uint
+        {
+            UNSIGNED_INT = DataType.UNSIGNED_INT,
+            UNSIGNED_SHORT_5_5_5_1_EXT = EXT_packed_pixels.UNSIGNED_SHORT_5_5_5_1_EXT,
+            FLOAT = DataType.FLOAT,
+            UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
+            SHORT = DataType.SHORT,
+            BYTE = DataType.BYTE,
+            UNSIGNED_INT_8_8_8_8_EXT = EXT_packed_pixels.UNSIGNED_INT_8_8_8_8_EXT,
+            UNSIGNED_BYTE_3_3_2_EXT = EXT_packed_pixels.UNSIGNED_BYTE_3_3_2_EXT,
+            INT = DataType.INT,
+            BITMAP = 0x1A00,
+            UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
+            UNSIGNED_INT_10_10_10_2_EXT = EXT_packed_pixels.UNSIGNED_INT_10_10_10_2_EXT,
+            UNSIGNED_SHORT_4_4_4_4_EXT = EXT_packed_pixels.UNSIGNED_SHORT_4_4_4_4_EXT,
+        }
+
+        public enum EXT_texture_env_combine : uint
+        {
+            SOURCE0_RGB_EXT = 0x8580,
+            COMBINE_RGB_EXT = 0x8571,
+            SOURCE1_RGB_EXT = 0x8581,
+            CONSTANT_EXT = 0x8576,
+            SOURCE1_ALPHA_EXT = 0x8589,
+            SOURCE2_ALPHA_EXT = 0x858A,
+            SOURCE2_RGB_EXT = 0x8582,
+            OPERAND0_RGB_EXT = 0x8590,
+            OPERAND0_ALPHA_EXT = 0x8598,
+            RGB_SCALE_EXT = 0x8573,
+            OPERAND1_RGB_EXT = 0x8591,
+            SOURCE0_ALPHA_EXT = 0x8588,
+            OPERAND2_ALPHA_EXT = 0x859A,
+            INTERPOLATE_EXT = 0x8575,
+            COMBINE_EXT = 0x8570,
+            OPERAND1_ALPHA_EXT = 0x8599,
+            OPERAND2_RGB_EXT = 0x8592,
+            PREVIOUS_EXT = 0x8578,
+            ADD_SIGNED_EXT = 0x8574,
+            PRIMARY_COLOR_EXT = 0x8577,
+            COMBINE_ALPHA_EXT = 0x8572,
+        }
+
+        public enum ATI_vertex_streams : uint
+        {
+            VERTEX_STREAM6_ATI = 0x8772,
+            VERTEX_STREAM1_ATI = 0x876D,
+            VERTEX_STREAM3_ATI = 0x876F,
+            MAX_VERTEX_STREAMS_ATI = 0x876B,
+            VERTEX_STREAM4_ATI = 0x8770,
+            VERTEX_STREAM0_ATI = 0x876C,
+            VERTEX_STREAM2_ATI = 0x876E,
+            VERTEX_SOURCE_ATI = 0x8774,
+            VERTEX_STREAM7_ATI = 0x8773,
+            VERTEX_STREAM5_ATI = 0x8771,
+        }
+
+        public enum EXT_point_parameters : uint
+        {
+            DISTANCE_ATTENUATION_EXT = 0x8129,
+            POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128,
+            POINT_SIZE_MAX_EXT = 0x8127,
+            POINT_SIZE_MIN_EXT = 0x8126,
+        }
+
+        public enum SGIX_fog_scale : uint
+        {
+            FOG_SCALE_SGIX = 0x81FC,
+            FOG_SCALE_VALUE_SGIX = 0x81FD,
+        }
+
+        public enum OML_interlace : uint
+        {
+            INTERLACE_READ_OML = 0x8981,
+            INTERLACE_OML = 0x8980,
+        }
+
+        public enum SGIS_texture_select : uint
+        {
+            DUAL_ALPHA16_SGIS = 0x8113,
+            QUAD_ALPHA8_SGIS = 0x811F,
+            DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C,
+            DUAL_LUMINANCE12_SGIS = 0x8116,
+            DUAL_ALPHA4_SGIS = 0x8110,
+            QUAD_TEXTURE_SELECT_SGIS = 0x8125,
+            DUAL_ALPHA12_SGIS = 0x8112,
+            QUAD_INTENSITY4_SGIS = 0x8122,
+            DUAL_INTENSITY16_SGIS = 0x811B,
+            DUAL_INTENSITY4_SGIS = 0x8118,
+            DUAL_LUMINANCE4_SGIS = 0x8114,
+            QUAD_INTENSITY8_SGIS = 0x8123,
+            DUAL_LUMINANCE16_SGIS = 0x8117,
+            DUAL_LUMINANCE8_SGIS = 0x8115,
+            QUAD_LUMINANCE8_SGIS = 0x8121,
+            DUAL_TEXTURE_SELECT_SGIS = 0x8124,
+            DUAL_ALPHA8_SGIS = 0x8111,
+            DUAL_INTENSITY12_SGIS = 0x811A,
+            DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D,
+            QUAD_LUMINANCE4_SGIS = 0x8120,
+            DUAL_INTENSITY8_SGIS = 0x8119,
+            QUAD_ALPHA4_SGIS = 0x811E,
+        }
+
+        public enum APPLE_transform_hint : uint
+        {
+            TRANSFORM_HINT_APPLE = 0x85B1,
+        }
+
+        public enum EXT_texture_compression_s3tc : uint
+        {
+            COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0,
+            COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1,
+            COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3,
+            COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2,
+        }
+
+        public enum ARB_draw_buffers : uint
+        {
+            DRAW_BUFFER13_ARB = 0x8832,
+            DRAW_BUFFER4_ARB = 0x8829,
+            DRAW_BUFFER1_ARB = 0x8826,
+            MAX_DRAW_BUFFERS_ARB = 0x8824,
+            DRAW_BUFFER2_ARB = 0x8827,
+            DRAW_BUFFER0_ARB = 0x8825,
+            DRAW_BUFFER8_ARB = 0x882D,
+            DRAW_BUFFER7_ARB = 0x882C,
+            DRAW_BUFFER10_ARB = 0x882F,
+            DRAW_BUFFER5_ARB = 0x882A,
+            DRAW_BUFFER15_ARB = 0x8834,
+            DRAW_BUFFER14_ARB = 0x8833,
+            DRAW_BUFFER3_ARB = 0x8828,
+            DRAW_BUFFER6_ARB = 0x882B,
+            DRAW_BUFFER12_ARB = 0x8831,
+            DRAW_BUFFER11_ARB = 0x8830,
+            DRAW_BUFFER9_ARB = 0x882E,
+        }
+
+        public enum EXT_index_material : uint
+        {
+            INDEX_MATERIAL_FACE_EXT = 0x81BA,
+            INDEX_MATERIAL_EXT = 0x81B8,
+            INDEX_MATERIAL_PARAMETER_EXT = 0x81B9,
+        }
+
+        public enum EXT_stencil_clear_tag : uint
+        {
+            STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3,
+            STENCIL_TAG_BITS_EXT = 0x88F2,
+        }
+
+        public enum EXT_framebuffer_object : uint
+        {
+            FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC,
+            COLOR_ATTACHMENT3_EXT = 0x8CE3,
+            COLOR_ATTACHMENT1_EXT = 0x8CE1,
+            FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0,
+            FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4,
+            RENDERBUFFER_EXT = 0x8D41,
+            COLOR_ATTACHMENT15_EXT = 0x8CEF,
+            COLOR_ATTACHMENT13_EXT = 0x8CED,
+            RENDERBUFFER_HEIGHT_EXT = 0x8D43,
+            COLOR_ATTACHMENT14_EXT = 0x8CEE,
+            COLOR_ATTACHMENT12_EXT = 0x8CEC,
+            RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44,
+            RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53,
+            FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9,
+            STENCIL_INDEX4_EXT = 0x8D47,
+            FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2,
+            COLOR_ATTACHMENT6_EXT = 0x8CE6,
+            FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7,
+            FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA,
+            RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54,
+            FRAMEBUFFER_BINDING_EXT = 0x8CA6,
+            COLOR_ATTACHMENT8_EXT = 0x8CE8,
+            FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6,
+            COLOR_ATTACHMENT2_EXT = 0x8CE2,
+            COLOR_ATTACHMENT9_EXT = 0x8CE9,
+            FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3,
+            FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB,
+            MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF,
+            RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51,
+            STENCIL_INDEX8_EXT = 0x8D48,
+            COLOR_ATTACHMENT7_EXT = 0x8CE7,
+            MAX_RENDERBUFFER_SIZE_EXT = 0x84E8,
+            STENCIL_INDEX1_EXT = 0x8D46,
+            DEPTH_ATTACHMENT_EXT = 0x8D00,
+            COLOR_ATTACHMENT0_EXT = 0x8CE0,
+            INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506,
+            RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52,
+            FRAMEBUFFER_EXT = 0x8D40,
+            RENDERBUFFER_WIDTH_EXT = 0x8D42,
+            STENCIL_INDEX16_EXT = 0x8D49,
+            FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = 0x8CD8,
+            COLOR_ATTACHMENT5_EXT = 0x8CE5,
+            FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD,
+            RENDERBUFFER_RED_SIZE_EXT = 0x8D50,
+            COLOR_ATTACHMENT11_EXT = 0x8CEB,
+            FRAMEBUFFER_COMPLETE_EXT = 0x8CD5,
+            COLOR_ATTACHMENT4_EXT = 0x8CE4,
+            COLOR_ATTACHMENT10_EXT = 0x8CEA,
+            RENDERBUFFER_BINDING_EXT = 0x8CA7,
+            RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55,
+            FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1,
+            STENCIL_ATTACHMENT_EXT = 0x8D20,
+        }
+
+        public enum SGIX_async : uint
+        {
+            ASYNC_MARKER_SGIX = 0x8329,
+        }
+
+        public enum EXT_texture_env_add : uint
+        {
+        }
+
+        public enum PixelTransferParameter : uint
+        {
+            POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT,
+            DEPTH_BIAS = GetPName.DEPTH_BIAS,
+            POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI,
+            POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT,
+            BLUE_SCALE = GetPName.BLUE_SCALE,
+            POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI,
+            BLUE_BIAS = GetPName.BLUE_BIAS,
+            POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI,
+            INDEX_OFFSET = GetPName.INDEX_OFFSET,
+            POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT,
+            POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI,
+            MAP_COLOR = GetPName.MAP_COLOR,
+            POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI,
+            MAP_STENCIL = GetPName.MAP_STENCIL,
+            POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT,
+            INDEX_SHIFT = GetPName.INDEX_SHIFT,
+            POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI,
+            POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT,
+            POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT,
+            POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI,
+            POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI,
+            RED_SCALE = GetPName.RED_SCALE,
+            GREEN_BIAS = GetPName.GREEN_BIAS,
+            RED_BIAS = GetPName.RED_BIAS,
+            POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT,
+            GREEN_SCALE = GetPName.GREEN_SCALE,
+            ALPHA_SCALE = GetPName.ALPHA_SCALE,
+            ALPHA_BIAS = GetPName.ALPHA_BIAS,
+            DEPTH_SCALE = GetPName.DEPTH_SCALE,
+            POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT,
+        }
+
+        public enum VERSION_1_3 : uint
+        {
+            TEXTURE14 = 0x84CE,
+            TEXTURE17 = 0x84D1,
+            TEXTURE16 = 0x84D0,
+            TEXTURE11 = 0x84CB,
+            TEXTURE10 = 0x84CA,
+            TEXTURE13 = 0x84CD,
+            TEXTURE12 = 0x84CC,
+            SAMPLE_ALPHA_TO_ONE = 0x809F,
+            TEXTURE_BINDING_CUBE_MAP = 0x8514,
+            TEXTURE19 = 0x84D3,
+            TEXTURE18 = 0x84D2,
+            PRIMARY_COLOR = 0x8577,
+            MULTISAMPLE = 0x809D,
+            TRANSPOSE_COLOR_MATRIX = 0x84E6,
+            TRANSPOSE_PROJECTION_MATRIX = 0x84E4,
+            CONSTANT = 0x8576,
+            COMBINE = 0x8570,
+            MULTISAMPLE_BIT = 0x20000000,
+            SOURCE2_ALPHA = 0x858A,
+            SAMPLES = 0x80A9,
+            COMPRESSED_ALPHA = 0x84E9,
+            TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517,
+            SAMPLE_COVERAGE = 0x80A0,
+            TRANSPOSE_MODELVIEW_MATRIX = 0x84E3,
+            SAMPLE_ALPHA_TO_COVERAGE = 0x809E,
+            SUBTRACT = 0x84E7,
+            SAMPLE_BUFFERS = 0x80A8,
+            DOT3_RGBA = 0x86AF,
+            DOT3_RGB = 0x86AE,
+            SOURCE1_ALPHA = 0x8589,
+            TEXTURE6 = 0x84C6,
+            TEXTURE2 = 0x84C2,
+            COMPRESSED_RGB = 0x84ED,
+            COMPRESSED_RGBA = 0x84EE,
+            TEXTURE9 = 0x84C9,
+            TEXTURE31 = 0x84DF,
+            TEXTURE30 = 0x84DE,
+            OPERAND1_ALPHA = 0x8599,
+            CLIENT_ACTIVE_TEXTURE = 0x84E1,
+            INTERPOLATE = 0x8575,
+            OPERAND1_RGB = 0x8591,
+            SOURCE2_RGB = 0x8582,
+            MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C,
+            TEXTURE_COMPRESSED = 0x86A1,
+            TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A,
+            RGB_SCALE = 0x8573,
+            SAMPLE_COVERAGE_INVERT = 0x80AB,
+            TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519,
+            NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2,
+            COMPRESSED_TEXTURE_FORMATS = 0x86A3,
+            TEXTURE5 = 0x84C5,
+            TEXTURE1 = 0x84C1,
+            COMBINE_RGB = 0x8571,
+            TEXTURE25 = 0x84D9,
+            TEXTURE8 = 0x84C8,
+            TEXTURE27 = 0x84DB,
+            TEXTURE26 = 0x84DA,
+            TEXTURE21 = 0x84D5,
+            TEXTURE20 = 0x84D4,
+            TEXTURE23 = 0x84D7,
+            TEXTURE22 = 0x84D6,
+            SAMPLE_COVERAGE_VALUE = 0x80AA,
+            TEXTURE29 = 0x84DD,
+            TEXTURE28 = 0x84DC,
+            TEXTURE_CUBE_MAP = 0x8513,
+            SOURCE0_ALPHA = 0x8588,
+            TEXTURE24 = 0x84D8,
+            SOURCE0_RGB = 0x8580,
+            ADD_SIGNED = 0x8574,
+            OPERAND0_ALPHA = 0x8598,
+            REFLECTION_MAP = 0x8512,
+            ACTIVE_TEXTURE = 0x84E0,
+            TRANSPOSE_TEXTURE_MATRIX = 0x84E5,
+            SOURCE1_RGB = 0x8581,
+            TEXTURE15 = 0x84CF,
+            COMPRESSED_LUMINANCE = 0x84EA,
+            CLAMP_TO_BORDER = 0x812D,
+            TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516,
+            OPERAND2_ALPHA = 0x859A,
+            COMPRESSED_INTENSITY = 0x84EC,
+            TEXTURE0 = 0x84C0,
+            NORMAL_MAP = 0x8511,
+            COMPRESSED_LUMINANCE_ALPHA = 0x84EB,
+            PROXY_TEXTURE_CUBE_MAP = 0x851B,
+            TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0,
+            OPERAND2_RGB = 0x8592,
+            TEXTURE4 = 0x84C4,
+            OPERAND0_RGB = 0x8590,
+            MAX_TEXTURE_UNITS = 0x84E2,
+            TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515,
+            TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518,
+            TEXTURE_COMPRESSION_HINT = 0x84EF,
+            COMBINE_ALPHA = 0x8572,
+            PREVIOUS = 0x8578,
+            TEXTURE7 = 0x84C7,
+            TEXTURE3 = 0x84C3,
+        }
+
+        public enum NV_vertex_program2 : uint
+        {
+        }
+
+        public enum EXT_polygon_offset : uint
+        {
+            POLYGON_OFFSET_BIAS_EXT = 0x8039,
+            POLYGON_OFFSET_EXT = 0x8037,
+            POLYGON_OFFSET_FACTOR_EXT = 0x8038,
+        }
+
+        public enum SGIX_texture_coordinate_clamp : uint
+        {
+            FOG_FACTOR_TO_ALPHA_SGIX = 0x836F,
+            TEXTURE_MAX_CLAMP_S_SGIX = 0x8369,
+            TEXTURE_MAX_CLAMP_R_SGIX = 0x836B,
+            TEXTURE_MAX_CLAMP_T_SGIX = 0x836A,
+        }
+
+        public enum SGIX_instruments : uint
+        {
+            INSTRUMENT_MEASUREMENTS_SGIX = 0x8181,
+            INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180,
+        }
+
+        public enum VERSION_2_0 : uint
+        {
+            MAX_VARYING_FLOATS = 0x8B4B,
+            VERTEX_ATTRIB_ARRAY_POINTER = 0x8645,
+            VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622,
+            DRAW_BUFFER13 = 0x8832,
+            VERTEX_PROGRAM_POINT_SIZE = 0x8642,
+            MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C,
+            MAX_TEXTURE_COORDS = 0x8871,
+            FLOAT_MAT4 = 0x8B5C,
+            SAMPLER_3D = 0x8B5F,
+            SAMPLER_1D_SHADOW = 0x8B61,
+            SAMPLER_1D = 0x8B5D,
+            ATTACHED_SHADERS = 0x8B85,
+            ACTIVE_ATTRIBUTES = 0x8B89,
+            LINK_STATUS = 0x8B82,
+            FLOAT_VEC4 = 0x8B52,
+            DRAW_BUFFER4 = 0x8829,
+            DRAW_BUFFER8 = 0x882D,
+            MAX_DRAW_BUFFERS = 0x8824,
+            INT_VEC2 = 0x8B53,
+            POINT_SPRITE_COORD_ORIGIN = 0x8CA0,
+            MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49,
+            SAMPLER_CUBE = 0x8B60,
+            DRAW_BUFFER12 = 0x8831,
+            DRAW_BUFFER11 = 0x8830,
+            DRAW_BUFFER10 = 0x882F,
+            FRAGMENT_SHADER = 0x8B30,
+            STENCIL_BACK_REF = 0x8CA3,
+            DRAW_BUFFER15 = 0x8834,
+            DRAW_BUFFER14 = 0x8833,
+            BOOL = 0x8B56,
+            CURRENT_VERTEX_ATTRIB = 0x8626,
+            ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A,
+            FLOAT_MAT2 = 0x8B5A,
+            ACTIVE_UNIFORMS = 0x8B86,
+            SAMPLER_2D = 0x8B5E,
+            INFO_LOG_LENGTH = 0x8B84,
+            MAX_VERTEX_ATTRIBS = 0x8869,
+            DRAW_BUFFER0 = 0x8825,
+            CURRENT_PROGRAM = 0x8B8D,
+            SHADING_LANGUAGE_VERSION = 0x8B8C,
+            FLOAT_VEC3 = 0x8B51,
+            DRAW_BUFFER5 = 0x882A,
+            DRAW_BUFFER9 = 0x882E,
+            STENCIL_BACK_FUNC = 0x8800,
+            COMPILE_STATUS = 0x8B81,
+            INT_VEC3 = 0x8B54,
+            STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802,
+            VERTEX_ATTRIB_ARRAY_SIZE = 0x8623,
+            BLEND_EQUATION_ALPHA = 0x883D,
+            STENCIL_BACK_PASS_DEPTH_PASS = 0x8803,
+            UPPER_LEFT = 0x8CA2,
+            VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624,
+            FLOAT_MAT3 = 0x8B5B,
+            SAMPLER_2D_SHADOW = 0x8B62,
+            VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A,
+            FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B,
+            BLEND_EQUATION_RGB = ARB_imaging.BLEND_EQUATION,
+            DRAW_BUFFER2 = 0x8827,
+            SHADER_SOURCE_LENGTH = 0x8B88,
+            DRAW_BUFFER7 = 0x882C,
+            SHADER_TYPE = 0x8B4F,
+            DRAW_BUFFER1 = 0x8826,
+            MAX_TEXTURE_IMAGE_UNITS = 0x8872,
+            POINT_SPRITE = 0x8861,
+            DRAW_BUFFER6 = 0x882B,
+            STENCIL_BACK_WRITEMASK = 0x8CA5,
+            STENCIL_BACK_VALUE_MASK = 0x8CA4,
+            COORD_REPLACE = 0x8862,
+            VERTEX_ATTRIB_ARRAY_TYPE = 0x8625,
+            LOWER_LEFT = 0x8CA1,
+            INT_VEC4 = 0x8B55,
+            FLOAT_VEC2 = 0x8B50,
+            MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A,
+            VALIDATE_STATUS = 0x8B83,
+            VERTEX_SHADER = 0x8B31,
+            MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D,
+            VERTEX_PROGRAM_TWO_SIDE = 0x8643,
+            DELETE_STATUS = 0x8B80,
+            STENCIL_BACK_FAIL = 0x8801,
+            ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87,
+            DRAW_BUFFER3 = 0x8828,
+            BOOL_VEC4 = 0x8B59,
+            BOOL_VEC3 = 0x8B58,
+            BOOL_VEC2 = 0x8B57,
+        }
+
+        public enum ARB_multitexture : uint
+        {
+            TEXTURE13_ARB = 0x84CD,
+            TEXTURE7_ARB = 0x84C7,
+            TEXTURE21_ARB = 0x84D5,
+            TEXTURE24_ARB = 0x84D8,
+            TEXTURE19_ARB = 0x84D3,
+            TEXTURE5_ARB = 0x84C5,
+            TEXTURE16_ARB = 0x84D0,
+            TEXTURE27_ARB = 0x84DB,
+            TEXTURE17_ARB = 0x84D1,
+            MAX_TEXTURE_UNITS_ARB = 0x84E2,
+            TEXTURE2_ARB = 0x84C2,
+            TEXTURE20_ARB = 0x84D4,
+            TEXTURE31_ARB = 0x84DF,
+            TEXTURE12_ARB = 0x84CC,
+            TEXTURE18_ARB = 0x84D2,
+            TEXTURE15_ARB = 0x84CF,
+            TEXTURE10_ARB = 0x84CA,
+            ACTIVE_TEXTURE_ARB = 0x84E0,
+            TEXTURE23_ARB = 0x84D7,
+            TEXTURE0_ARB = 0x84C0,
+            TEXTURE29_ARB = 0x84DD,
+            TEXTURE26_ARB = 0x84DA,
+            TEXTURE8_ARB = 0x84C8,
+            TEXTURE3_ARB = 0x84C3,
+            TEXTURE30_ARB = 0x84DE,
+            TEXTURE11_ARB = 0x84CB,
+            TEXTURE9_ARB = 0x84C9,
+            CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1,
+            TEXTURE14_ARB = 0x84CE,
+            TEXTURE6_ARB = 0x84C6,
+            TEXTURE22_ARB = 0x84D6,
+            TEXTURE28_ARB = 0x84DC,
+            TEXTURE25_ARB = 0x84D9,
+            TEXTURE1_ARB = 0x84C1,
+            TEXTURE4_ARB = 0x84C4,
+        }
+
+        public enum EXT_histogram : uint
+        {
+            HISTOGRAM_WIDTH = 0x8026,
+            PROXY_HISTOGRAM = 0x8025,
+            MINMAX_EXT = 0x802E,
+            MINMAX_SINK_EXT = 0x8030,
+            MINMAX_FORMAT_EXT = 0x802F,
+            HISTOGRAM_BLUE_SIZE = 0x802A,
+            HISTOGRAM_SINK_EXT = 0x802D,
+            HISTOGRAM_LUMINANCE_SIZE = 0x802C,
+            HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C,
+            HISTOGRAM_EXT = 0x8024,
+            HISTOGRAM_ALPHA_SIZE = 0x802B,
+            HISTOGRAM_FORMAT_EXT = 0x8027,
+            HISTOGRAM_RED_SIZE_EXT = 0x8028,
+            MINMAX = 0x802E,
+            MINMAX_SINK = 0x8030,
+            PROXY_HISTOGRAM_EXT = 0x8025,
+            HISTOGRAM_RED_SIZE = 0x8028,
+            HISTOGRAM_ALPHA_SIZE_EXT = 0x802B,
+            HISTOGRAM_BLUE_SIZE_EXT = 0x802A,
+            MINMAX_FORMAT = 0x802F,
+            HISTOGRAM_WIDTH_EXT = 0x8026,
+            HISTOGRAM_FORMAT = 0x8027,
+            TABLE_TOO_LARGE = 0x8031,
+            HISTOGRAM_SINK = 0x802D,
+            HISTOGRAM_GREEN_SIZE_EXT = 0x8029,
+            TABLE_TOO_LARGE_EXT = 0x8031,
+            HISTOGRAM = 0x8024,
+            HISTOGRAM_GREEN_SIZE = 0x8029,
+        }
+
+        public enum PixelFormat : uint
+        {
+            CMYK_EXT = EXT_cmyka.CMYK_EXT,
+            YCRCB_444_SGIX = SGIX_ycrcb.YCRCB_444_SGIX,
+            R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX,
+            ALPHA = 0x1906,
+            RGBA = 0x1908,
+            GREEN = 0x1904,
+            R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX,
+            LUMINANCE_ALPHA = 0x190A,
+            STENCIL_INDEX = 0x1901,
+            RED = 0x1903,
+            BLUE = 0x1905,
+            CMYKA_EXT = EXT_cmyka.CMYKA_EXT,
+            ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX,
+            LUMINANCE = 0x1909,
+            LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX,
+            YCRCB_422_SGIX = SGIX_ycrcb.YCRCB_422_SGIX,
+            ABGR_EXT = EXT_abgr.ABGR_EXT,
+            COLOR_INDEX = 0x1900,
+            RGB = 0x1907,
+            LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX,
+            DEPTH_COMPONENT = 0x1902,
+        }
+
+        public enum NV_occlusion_query : uint
+        {
+            CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865,
+            PIXEL_COUNT_NV = 0x8866,
+            PIXEL_COUNTER_BITS_NV = 0x8864,
+            PIXEL_COUNT_AVAILABLE_NV = 0x8867,
+        }
+
+        public enum MapTarget : uint
+        {
+            MAP2_COLOR_4 = GetPName.MAP2_COLOR_4,
+            MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4,
+            MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3,
+            GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX,
+            MAP2_INDEX = GetPName.MAP2_INDEX,
+            MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1,
+            TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX,
+            MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1,
+            MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4,
+            MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3,
+            MAP1_INDEX = GetPName.MAP1_INDEX,
+            MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4,
+            MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2,
+            MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2,
+            MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3,
+            MAP1_COLOR_4 = GetPName.MAP1_COLOR_4,
+            MAP2_NORMAL = GetPName.MAP2_NORMAL,
+            MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4,
+            MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3,
+            MAP1_NORMAL = GetPName.MAP1_NORMAL,
+        }
+
+        public enum ListParameterName : uint
+        {
+            LIST_PRIORITY_SGIX = SGIX_list_priority.LIST_PRIORITY_SGIX,
+        }
+
+        public enum IBM_texture_mirrored_repeat : uint
+        {
+            MIRRORED_REPEAT_IBM = 0x8370,
+        }
+
+        public enum SGIX_vertex_preclip : uint
+        {
+            VERTEX_PRECLIP_HINT_SGIX = 0x83EF,
+            VERTEX_PRECLIP_SGIX = 0x83EE,
+        }
+
+        public enum PixelStoreSubsampleRate : uint
+        {
+            PIXEL_SUBSAMPLE_2424_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_2424_SGIX,
+            PIXEL_SUBSAMPLE_4444_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4444_SGIX,
+            PIXEL_SUBSAMPLE_4242_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4242_SGIX,
+        }
+
+        public enum SUN_convolution_border_modes : uint
+        {
+            WRAP_BORDER_SUN = 0x81D4,
+        }
+
+        public enum SGIS_generate_mipmap : uint
+        {
+            GENERATE_MIPMAP_HINT = 0x8192,
+            TEXTURE_DEFORMATION_SGIX = 0x8195,
+            GENERATE_MIPMAP = 0x8191,
+            GEOMETRY_DEFORMATION_SGIX = 0x8194,
+            GENERATE_MIPMAP_HINT_SGIS = 0x8192,
+            GENERATE_MIPMAP_SGIS = 0x8191,
+            DEFORMATIONS_MASK_SGIX = 0x8196,
+            MAX_DEFORMATION_ORDER_SGIX = 0x8197,
+        }
+
+        public enum EXT_index_array_formats : uint
+        {
+            IUI_N3F_V2F_EXT = 0x81AF,
+            T2F_IUI_V3F_EXT = 0x81B2,
+            T2F_IUI_V2F_EXT = 0x81B1,
+            IUI_N3F_V3F_EXT = 0x81B0,
+            T2F_IUI_N3F_V3F_EXT = 0x81B4,
+            T2F_IUI_N3F_V2F_EXT = 0x81B3,
+            IUI_V3F_EXT = 0x81AE,
+            IUI_V2F_EXT = 0x81AD,
+        }
+
+        public enum BlendEquationModeEXT : uint
+        {
+            MAX_EXT = EXT_blend_minmax.MAX_EXT,
+            LOGIC_OP = GetPName.LOGIC_OP,
+            FUNC_ADD_EXT = EXT_blend_minmax.FUNC_ADD_EXT,
+            FUNC_SUBTRACT_EXT = EXT_blend_subtract.FUNC_SUBTRACT_EXT,
+            ALPHA_MAX_SGIX = SGIX_blend_alpha_minmax.ALPHA_MAX_SGIX,
+            FUNC_REVERSE_SUBTRACT_EXT = EXT_blend_subtract.FUNC_REVERSE_SUBTRACT_EXT,
+            ALPHA_MIN_SGIX = SGIX_blend_alpha_minmax.ALPHA_MIN_SGIX,
+            MIN_EXT = EXT_blend_minmax.MIN_EXT,
+        }
+
+        public enum NV_multisample_filter_hint : uint
+        {
+            MULTISAMPLE_FILTER_HINT_NV = 0x8534,
+        }
+
+        public enum NV_texgen_emboss : uint
+        {
+            EMBOSS_CONSTANT_NV = 0x855E,
+            EMBOSS_LIGHT_NV = 0x855D,
+            EMBOSS_MAP_NV = 0x855F,
+        }
+
+        public enum NV_fragment_program_option : uint
+        {
+        }
+
+        public enum HP_image_transform : uint
+        {
+            IMAGE_TRANSFORM_2D_HP = 0x8161,
+            IMAGE_MIN_FILTER_HP = 0x815D,
+            IMAGE_TRANSLATE_Y_HP = 0x8158,
+            IMAGE_TRANSLATE_X_HP = 0x8157,
+            AVERAGE_HP = 0x8160,
+            POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162,
+            IMAGE_SCALE_Y_HP = 0x8156,
+            IMAGE_SCALE_X_HP = 0x8155,
+            CUBIC_HP = 0x815F,
+            IMAGE_MAG_FILTER_HP = 0x815C,
+            IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B,
+            IMAGE_ROTATE_ORIGIN_X_HP = 0x815A,
+            PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163,
+            IMAGE_CUBIC_WEIGHT_HP = 0x815E,
+            IMAGE_ROTATE_ANGLE_HP = 0x8159,
+        }
+
+        public enum NV_half_float : uint
+        {
+            HALF_FLOAT_NV = 0x140B,
+        }
+
+        public enum APPLE_vertex_array_range : uint
+        {
+            STORAGE_SHARED_APPLE = 0x85BF,
+            VERTEX_ARRAY_RANGE_APPLE = 0x851D,
+            VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F,
+            VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E,
+            VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521,
+            STORAGE_CACHED_APPLE = 0x85BE,
+        }
+
+        public enum NV_texture_compression_vtc : uint
+        {
+        }
+
+        public enum NV_texture_expand_normal : uint
+        {
+            TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F,
+        }
+
+        public enum S3_s3tc : uint
+        {
+            RGB4_S3TC = 0x83A1,
+            RGBA_S3TC = 0x83A2,
+            RGB_S3TC = 0x83A0,
+            RGBA4_S3TC = 0x83A3,
+        }
+
+        public enum ARB_fragment_shader : uint
+        {
+            MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49,
+            FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B,
+            FRAGMENT_SHADER_ARB = 0x8B30,
+        }
+
+        public enum TexCoordPointerType : uint
+        {
+            DOUBLE = DataType.DOUBLE,
+            INT = DataType.INT,
+            SHORT = DataType.SHORT,
+            FLOAT = DataType.FLOAT,
+        }
+
+        public enum ClearBufferMask : uint
+        {
+            STENCIL_BUFFER_BIT = AttribMask.STENCIL_BUFFER_BIT,
+            ACCUM_BUFFER_BIT = AttribMask.ACCUM_BUFFER_BIT,
+            COLOR_BUFFER_BIT = AttribMask.COLOR_BUFFER_BIT,
+            DEPTH_BUFFER_BIT = AttribMask.DEPTH_BUFFER_BIT,
+        }
+
+        public enum SGIX_ycrcb : uint
+        {
+            YCRCB_422_SGIX = 0x81BB,
+            YCRCB_444_SGIX = 0x81BC,
+        }
+
+        public enum EXT_rescale_normal : uint
+        {
+            RESCALE_NORMAL_EXT = 0x803A,
+            RESCALE_NORMAL = 0x803A,
+        }
+
+        public enum ARB_shader_objects : uint
+        {
+            OBJECT_VALIDATE_STATUS_ARB = 0x8B83,
+            BOOL_VEC3_ARB = 0x8B58,
+            SAMPLER_2D_RECT_ARB = 0x8B63,
+            OBJECT_COMPILE_STATUS_ARB = 0x8B81,
+            OBJECT_DELETE_STATUS_ARB = 0x8B80,
+            OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87,
+            FLOAT_MAT2_ARB = 0x8B5A,
+            BOOL_ARB = 0x8B56,
+            FLOAT_MAT4_ARB = 0x8B5C,
+            OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88,
+            SAMPLER_3D_ARB = 0x8B5F,
+            OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84,
+            INT_VEC4_ARB = 0x8B55,
+            FLOAT_MAT3_ARB = 0x8B5B,
+            PROGRAM_OBJECT_ARB = 0x8B40,
+            SAMPLER_1D_SHADOW_ARB = 0x8B61,
+            OBJECT_TYPE_ARB = 0x8B4E,
+            BOOL_VEC4_ARB = 0x8B59,
+            BOOL_VEC2_ARB = 0x8B57,
+            OBJECT_SUBTYPE_ARB = 0x8B4F,
+            SAMPLER_1D_ARB = 0x8B5D,
+            SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64,
+            SHADER_OBJECT_ARB = 0x8B48,
+            FLOAT_VEC2_ARB = 0x8B50,
+            SAMPLER_2D_SHADOW_ARB = 0x8B62,
+            OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85,
+            FLOAT_VEC4_ARB = 0x8B52,
+            OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86,
+            SAMPLER_CUBE_ARB = 0x8B60,
+            SAMPLER_2D_ARB = 0x8B5E,
+            INT_VEC2_ARB = 0x8B53,
+            OBJECT_LINK_STATUS_ARB = 0x8B82,
+            INT_VEC3_ARB = 0x8B54,
+            FLOAT_VEC3_ARB = 0x8B51,
+        }
+
+        public enum SGIX_shadow_ambient : uint
+        {
+            SHADOW_AMBIENT_SGIX = 0x80BF,
+        }
+
+        public enum SUNX_constant_data : uint
+        {
+            TEXTURE_CONSTANT_DATA_SUNX = 0x81D6,
+            UNPACK_CONSTANT_DATA_SUNX = 0x81D5,
+        }
+
+        public enum EXT_blend_minmax : uint
+        {
+            MAX_EXT = 0x8008,
+            BLEND_EQUATION_EXT = 0x8009,
+            MIN = 0x8007,
+            FUNC_ADD_EXT = 0x8006,
+            FUNC_ADD = 0x8006,
+            MAX = 0x8008,
+            MIN_EXT = 0x8007,
+            BLEND_EQUATION = 0x8009,
+        }
+
+        public enum EXT_packed_pixels : uint
+        {
+            UNSIGNED_BYTE_3_3_2 = 0x8032,
+            UNSIGNED_INT_2_10_10_10_REV = 0x8368,
+            UNSIGNED_INT_10_10_10_2 = 0x8036,
+            UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
+            UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364,
+            UNSIGNED_INT_8_8_8_8 = 0x8035,
+            UNSIGNED_SHORT_5_6_5 = 0x8363,
+            UNSIGNED_INT_8_8_8_8_REV = 0x8367,
+            UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
+            UNSIGNED_INT_8_8_8_8_EXT = 0x8035,
+            UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366,
+            UNSIGNED_SHORT_5_6_5_REV = 0x8364,
+            UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365,
+            UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368,
+            UNSIGNED_BYTE_2_3_3_REV = 0x8362,
+            UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362,
+            UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033,
+            UNSIGNED_INT_10_10_10_2_EXT = 0x8036,
+            UNSIGNED_SHORT_5_6_5_EXT = 0x8363,
+            UNSIGNED_SHORT_5_5_5_1 = 0x8034,
+            UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367,
+            UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034,
+            UNSIGNED_BYTE_3_3_2_EXT = 0x8032,
+            UNSIGNED_SHORT_4_4_4_4 = 0x8033,
+        }
+
+        public enum LightEnvParameterSGIX : uint
+        {
+            LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX,
+        }
+
+        public enum EXT_blend_color : uint
+        {
+            CONSTANT_COLOR_EXT = 0x8001,
+            CONSTANT_ALPHA = 0x8003,
+            BLEND_COLOR_EXT = 0x8005,
+            CONSTANT_ALPHA_EXT = 0x8003,
+            ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002,
+            ONE_MINUS_CONSTANT_COLOR = 0x8002,
+            ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004,
+            CONSTANT_COLOR = 0x8001,
+            BLEND_COLOR = 0x8005,
+            ONE_MINUS_CONSTANT_ALPHA = 0x8004,
+        }
+
+        public enum INTEL_texture_scissor : uint
+        {
+        }
+
+        public enum PixelTexGenMode : uint
+        {
+            RGB = PixelFormat.RGB,
+            NONE = DrawBufferMode.NONE,
+            LUMINANCE = PixelFormat.LUMINANCE,
+            PIXEL_TEX_GEN_ALPHA_MS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_MS_SGIX,
+            PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX,
+            PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX,
+            LUMINANCE_ALPHA = PixelFormat.LUMINANCE_ALPHA,
+            PIXEL_TEX_GEN_ALPHA_LS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_LS_SGIX,
+            RGBA = PixelFormat.RGBA,
+        }
+
+        public enum EXT_copy_texture : uint
+        {
+        }
+
+        public enum NV_light_max_exponent : uint
+        {
+            MAX_SPOT_EXPONENT_NV = 0x8505,
+            MAX_SHININESS_NV = 0x8504,
+        }
+
+        public enum EXT_depth_bounds_test : uint
+        {
+            DEPTH_BOUNDS_EXT = 0x8891,
+            DEPTH_BOUNDS_TEST_EXT = 0x8890,
+        }
+
+        public enum ARB_texture_float : uint
+        {
+            TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14,
+            TEXTURE_BLUE_TYPE_ARB = 0x8C12,
+            LUMINANCE_ALPHA32F_ARB = 0x8819,
+            TEXTURE_DEPTH_TYPE_ARB = 0x8C16,
+            RGB32F_ARB = 0x8815,
+            LUMINANCE16F_ARB = 0x881E,
+            TEXTURE_RED_TYPE_ARB = 0x8C10,
+            TEXTURE_GREEN_TYPE_ARB = 0x8C11,
+            ALPHA16F_ARB = 0x881C,
+            TEXTURE_INTENSITY_TYPE_ARB = 0x8C15,
+            INTENSITY32F_ARB = 0x8817,
+            TEXTURE_ALPHA_TYPE_ARB = 0x8C13,
+            INTENSITY16F_ARB = 0x881D,
+            LUMINANCE32F_ARB = 0x8818,
+            LUMINANCE_ALPHA16F_ARB = 0x881F,
+            RGBA16F_ARB = 0x881A,
+            RGB16F_ARB = 0x881B,
+            ALPHA32F_ARB = 0x8816,
+            UNSIGNED_NORMALIZED_ARB = 0x8C17,
+            RGBA32F_ARB = 0x8814,
+        }
+
+        public enum FogMode : uint
+        {
+            EXP2 = 0x0801,
+            EXP = 0x0800,
+            LINEAR = TextureMagFilter.LINEAR,
+            FOG_FUNC_SGIS = SGIS_fog_function.FOG_FUNC_SGIS,
+        }
+
+        public enum EXT_422_pixels : uint
+        {
+            _422_REV_EXT = 0x80CD,
+            _422_EXT = 0x80CC,
+            _422_REV_AVERAGE_EXT = 0x80CF,
+            _422_AVERAGE_EXT = 0x80CE,
+        }
+
+        public enum ColorTableParameterPNameSGI : uint
+        {
+            COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI,
+            COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI,
+        }
+
+        public enum SGIX_calligraphic_fragment : uint
+        {
+            CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183,
+        }
+
+        public enum SGIS_texture_border_clamp : uint
+        {
+            CLAMP_TO_BORDER_SGIS = 0x812D,
+            CLAMP_TO_BORDER_ARB = 0x812D,
+            CLAMP_TO_BORDER = 0x812D,
+        }
+
+        public enum ARB_texture_env_dot3 : uint
+        {
+            DOT3_RGB_ARB = 0x86AE,
+            DOT3_RGBA_ARB = 0x86AF,
+        }
+
+        public enum HintTarget : uint
+        {
+            GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS,
+            POLYGON_SMOOTH_HINT = GetPName.POLYGON_SMOOTH_HINT,
+            VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX,
+            LINE_SMOOTH_HINT = GetPName.LINE_SMOOTH_HINT,
+            POINT_SMOOTH_HINT = GetPName.POINT_SMOOTH_HINT,
+            PERSPECTIVE_CORRECTION_HINT = GetPName.PERSPECTIVE_CORRECTION_HINT,
+            UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT,
+            FOG_HINT = GetPName.FOG_HINT,
+            CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX,
+            TEXTURE_MULTI_BUFFER_HINT_SGIX = SGIX_texture_multi_buffer.TEXTURE_MULTI_BUFFER_HINT_SGIX,
+            PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT,
+        }
+
+        public enum MESA_resize_buffers : uint
+        {
+        }
+
+        public enum VERSION_1_4 : uint
+        {
+            DECR_WRAP = 0x8508,
+            GENERATE_MIPMAP = 0x8191,
+            FRAGMENT_DEPTH = 0x8452,
+            MAX_TEXTURE_LOD_BIAS = 0x84FD,
+            FOG_COORDINATE_ARRAY = 0x8457,
+            BLEND_DST_RGB = 0x80C8,
+            GENERATE_MIPMAP_HINT = 0x8192,
+            BLEND_SRC_ALPHA = 0x80CB,
+            TEXTURE_COMPARE_MODE = 0x884C,
+            FOG_COORDINATE_ARRAY_STRIDE = 0x8455,
+            TEXTURE_FILTER_CONTROL = 0x8500,
+            DEPTH_COMPONENT24 = 0x81A6,
+            FOG_COORDINATE_SOURCE = 0x8450,
+            POINT_SIZE_MAX = 0x8127,
+            POINT_DISTANCE_ATTENUATION = 0x8129,
+            SECONDARY_COLOR_ARRAY_SIZE = 0x845A,
+            DEPTH_TEXTURE_MODE = 0x884B,
+            DEPTH_COMPONENT16 = 0x81A5,
+            FOG_COORDINATE_ARRAY_TYPE = 0x8454,
+            MIRRORED_REPEAT = 0x8370,
+            CURRENT_SECONDARY_COLOR = 0x8459,
+            SECONDARY_COLOR_ARRAY_POINTER = 0x845D,
+            SECONDARY_COLOR_ARRAY_STRIDE = 0x845C,
+            DEPTH_COMPONENT32 = 0x81A7,
+            TEXTURE_COMPARE_FUNC = 0x884D,
+            TEXTURE_DEPTH_SIZE = 0x884A,
+            BLEND_DST_ALPHA = 0x80CA,
+            CURRENT_FOG_COORDINATE = 0x8453,
+            POINT_FADE_THRESHOLD_SIZE = 0x8128,
+            COMPARE_R_TO_TEXTURE = 0x884E,
+            TEXTURE_LOD_BIAS = 0x8501,
+            FOG_COORDINATE_ARRAY_POINTER = 0x8456,
+            BLEND_SRC_RGB = 0x80C9,
+            COLOR_SUM = 0x8458,
+            FOG_COORDINATE = 0x8451,
+            SECONDARY_COLOR_ARRAY_TYPE = 0x845B,
+            POINT_SIZE_MIN = 0x8126,
+            INCR_WRAP = 0x8507,
+            SECONDARY_COLOR_ARRAY = 0x845E,
+        }
+
+        public enum LightName : uint
+        {
+            FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX,
+            FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX,
+            LIGHT4 = 0x4004,
+            LIGHT3 = 0x4003,
+            FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX,
+            LIGHT6 = 0x4006,
+            FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX,
+            LIGHT5 = 0x4005,
+            LIGHT0 = 0x4000,
+            FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX,
+            FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX,
+            LIGHT7 = 0x4007,
+            LIGHT2 = 0x4002,
+            FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
+            LIGHT1 = 0x4001,
+            FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX,
+        }
+
+        public enum SGIS_point_parameters : uint
+        {
+            POINT_SIZE_MIN_SGIS = 0x8126,
+            POINT_SIZE_MAX_SGIS = 0x8127,
+            POINT_DISTANCE_ATTENUATION = 0x8129,
+            DISTANCE_ATTENUATION_EXT = 0x8129,
+            POINT_FADE_THRESHOLD_SIZE = 0x8128,
+            POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128,
+            POINT_SIZE_MIN_EXT = 0x8126,
+            POINT_SIZE_MAX = 0x8127,
+            POINT_DISTANCE_ATTENUATION_ARB = 0x8129,
+            POINT_SIZE_MIN = 0x8126,
+            POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128,
+            DISTANCE_ATTENUATION_SGIS = 0x8129,
+            POINT_SIZE_MAX_EXT = 0x8127,
+            POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128,
+            POINT_SIZE_MAX_ARB = 0x8127,
+            POINT_SIZE_MIN_ARB = 0x8126,
+        }
+
+        public enum EXT_packed_depth_stencil : uint
+        {
+            DEPTH_STENCIL_EXT = 0x84F9,
+            TEXTURE_STENCIL_SIZE_EXT = 0x88F1,
+            UNSIGNED_INT_24_8_EXT = 0x84FA,
+            DEPTH24_STENCIL8_EXT = 0x88F0,
+        }
+
+        public enum EXT_color_subtable : uint
+        {
+        }
+
+        public enum MESA_ycbcr_texture : uint
+        {
+            UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB,
+            YCBCR_MESA = 0x8757,
+            UNSIGNED_SHORT_8_8_MESA = 0x85BA,
+        }
+
+        public enum SGIX_shadow : uint
+        {
+            TEXTURE_LEQUAL_R_SGIX = 0x819C,
+            TEXTURE_COMPARE_SGIX = 0x819A,
+            TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B,
+            TEXTURE_GEQUAL_R_SGIX = 0x819D,
+        }
+
+        public enum ARB_texture_mirrored_repeat : uint
+        {
+            MIRRORED_REPEAT_ARB = 0x8370,
+        }
+
+        public enum EXT_texture_object : uint
+        {
+            TEXTURE_2D_BINDING_EXT = 0x8069,
+            TEXTURE_1D_BINDING_EXT = 0x8068,
+            TEXTURE_PRIORITY_EXT = 0x8066,
+            TEXTURE_3D_BINDING_EXT = 0x806A,
+            TEXTURE_RESIDENT_EXT = 0x8067,
+        }
+
+        public enum EXT_texture_filter_anisotropic : uint
+        {
+            TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE,
+            MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF,
+        }
+
+        public enum SGIS_multisample : uint
+        {
+            SAMPLE_PATTERN_SGIS = 0x80AC,
+            _1PASS_SGIS = 0x80A1,
+            _2PASS_1_SGIS = 0x80A3,
+            _2PASS_0_SGIS = 0x80A2,
+            _4PASS_3_SGIS = 0x80A7,
+            _4PASS_0_SGIS = 0x80A4,
+            SAMPLE_MASK_SGIS = 0x80A0,
+            _4PASS_1_SGIS = 0x80A5,
+            SAMPLES_SGIS = 0x80A9,
+            MULTISAMPLE_SGIS = 0x809D,
+            SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E,
+            _4PASS_2_SGIS = 0x80A6,
+            SAMPLE_MASK_INVERT_SGIS = 0x80AB,
+            SAMPLE_BUFFERS_SGIS = 0x80A8,
+            SAMPLE_MASK_VALUE_SGIS = 0x80AA,
+            SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F,
+        }
+
+        public enum GetPixelMap : uint
+        {
+            PIXEL_MAP_B_TO_B = 0x0C78,
+            PIXEL_MAP_S_TO_S = 0x0C71,
+            PIXEL_MAP_R_TO_R = 0x0C76,
+            PIXEL_MAP_I_TO_B = 0x0C74,
+            PIXEL_MAP_I_TO_G = 0x0C73,
+            PIXEL_MAP_I_TO_A = 0x0C75,
+            PIXEL_MAP_A_TO_A = 0x0C79,
+            PIXEL_MAP_G_TO_G = 0x0C77,
+            PIXEL_MAP_I_TO_I = 0x0C70,
+            PIXEL_MAP_I_TO_R = 0x0C72,
+        }
+
+        public enum EXT_pixel_transform : uint
+        {
+            PIXEL_MIN_FILTER_EXT = 0x8332,
+            PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336,
+            PIXEL_TRANSFORM_2D_EXT = 0x8330,
+            MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337,
+            CUBIC_EXT = 0x8334,
+            PIXEL_CUBIC_WEIGHT_EXT = 0x8333,
+            AVERAGE_EXT = 0x8335,
+            PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338,
+            PIXEL_MAG_FILTER_EXT = 0x8331,
+        }
+
+        public enum PGI_vertex_hints : uint
+        {
+            MAT_SPECULAR_BIT_PGI = 0x04000000,
+            TEXCOORD2_BIT_PGI = 0x20000000,
+            VERTEX_CONSISTENT_HINT_PGI = 0x1A22B,
+            MAT_SHININESS_BIT_PGI = 0x02000000,
+            MAT_AMBIENT_BIT_PGI = 0x00100000,
+            MATERIAL_SIDE_HINT_PGI = 0x1A22C,
+            TEXCOORD3_BIT_PGI = 0x40000000,
+            TEXCOORD4_BIT_PGI = 0x80000000,
+            MAT_COLOR_INDEXES_BIT_PGI = 0x01000000,
+            MAX_VERTEX_HINT_PGI = 0x1A22D,
+            VERTEX23_BIT_PGI = 0x00000004,
+            TEXCOORD1_BIT_PGI = 0x10000000,
+            INDEX_BIT_PGI = 0x00080000,
+            EDGEFLAG_BIT_PGI = 0x00040000,
+            COLOR3_BIT_PGI = 0x00010000,
+            VERTEX_DATA_HINT_PGI = 0x1A22A,
+            MAT_DIFFUSE_BIT_PGI = 0x00400000,
+            NORMAL_BIT_PGI = 0x08000000,
+            MAT_EMISSION_BIT_PGI = 0x00800000,
+            COLOR4_BIT_PGI = 0x00020000,
+            VERTEX4_BIT_PGI = 0x00000008,
+            MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000,
+        }
+
+        public enum LightModelParameter : uint
+        {
+            LIGHT_MODEL_LOCAL_VIEWER = GetPName.LIGHT_MODEL_LOCAL_VIEWER,
+            LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL,
+            LIGHT_MODEL_AMBIENT = GetPName.LIGHT_MODEL_AMBIENT,
+            LIGHT_MODEL_TWO_SIDE = GetPName.LIGHT_MODEL_TWO_SIDE,
+        }
+
+        public enum NV_register_combiners : uint
+        {
+            COMBINER_MAPPING_NV = 0x8543,
+            SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532,
+            COMBINER_CD_OUTPUT_NV = 0x854B,
+            ZERO = BlendingFactorDest.ZERO,
+            COMBINER_INPUT_NV = 0x8542,
+            COMBINER5_NV = 0x8555,
+            SIGNED_NEGATE_NV = 0x853D,
+            COMBINER_SUM_OUTPUT_NV = 0x854C,
+            SCALE_BY_TWO_NV = 0x853E,
+            REGISTER_COMBINERS_NV = 0x8522,
+            COMBINER6_NV = 0x8556,
+            SCALE_BY_FOUR_NV = 0x853F,
+            E_TIMES_F_NV = 0x8531,
+            PRIMARY_COLOR_NV = 0x852C,
+            COMBINER2_NV = 0x8552,
+            COMBINER3_NV = 0x8553,
+            COMBINER0_NV = 0x8550,
+            COMBINER1_NV = 0x8551,
+            VARIABLE_F_NV = 0x8528,
+            FOG = GetPName.FOG,
+            SIGNED_IDENTITY_NV = 0x853C,
+            SECONDARY_COLOR_NV = 0x852D,
+            SCALE_BY_ONE_HALF_NV = 0x8540,
+            COMBINER_AB_OUTPUT_NV = 0x854A,
+            NONE = DrawBufferMode.NONE,
+            CONSTANT_COLOR0_NV = 0x852A,
+            COMBINER_CD_DOT_PRODUCT_NV = 0x8546,
+            TEXTURE0_ARB = ARB_multitexture.TEXTURE0_ARB,
+            UNSIGNED_INVERT_NV = 0x8537,
+            NUM_GENERAL_COMBINERS_NV = 0x854E,
+            COMBINER_BIAS_NV = 0x8549,
+            VARIABLE_B_NV = 0x8524,
+            EXPAND_NORMAL_NV = 0x8538,
+            VARIABLE_C_NV = 0x8525,
+            HALF_BIAS_NORMAL_NV = 0x853A,
+            COMBINER_COMPONENT_USAGE_NV = 0x8544,
+            COMBINER_SCALE_NV = 0x8548,
+            VARIABLE_A_NV = 0x8523,
+            HALF_BIAS_NEGATE_NV = 0x853B,
+            DISCARD_NV = 0x8530,
+            COMBINER_AB_DOT_PRODUCT_NV = 0x8545,
+            UNSIGNED_IDENTITY_NV = 0x8536,
+            EXPAND_NEGATE_NV = 0x8539,
+            VARIABLE_D_NV = 0x8526,
+            BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541,
+            VARIABLE_E_NV = 0x8527,
+            COMBINER_MUX_SUM_NV = 0x8547,
+            MAX_GENERAL_COMBINERS_NV = 0x854D,
+            COMBINER7_NV = 0x8557,
+            COMBINER4_NV = 0x8554,
+            COLOR_SUM_CLAMP_NV = 0x854F,
+            TEXTURE1_ARB = ARB_multitexture.TEXTURE1_ARB,
+            SPARE1_NV = 0x852F,
+            CONSTANT_COLOR1_NV = 0x852B,
+            SPARE0_NV = 0x852E,
+            VARIABLE_G_NV = 0x8529,
+        }
+
+        public enum ATI_vertex_attrib_array_object : uint
+        {
+        }
+
+        public enum NV_vertex_array_range2 : uint
+        {
+            VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533,
+        }
+
+        public enum ARB_half_float_pixel : uint
+        {
+            HALF_FLOAT_ARB = 0x140B,
+        }
+
+        public enum EXT_separate_specular_color : uint
+        {
+            SINGLE_COLOR_EXT = 0x81F9,
+            LIGHT_MODEL_COLOR_CONTROL = 0x81F8,
+            SEPARATE_SPECULAR_COLOR_EXT = 0x81FA,
+            LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8,
+            SEPARATE_SPECULAR_COLOR = 0x81FA,
+            SINGLE_COLOR = 0x81F9,
+        }
+
+        public enum EXT_blend_logic_op : uint
+        {
+        }
+
+        public enum ATI_envmap_bumpmap : uint
+        {
+            BUMP_TARGET_ATI = 0x877C,
+            BUMP_ROT_MATRIX_ATI = 0x8775,
+            DU8DV8_ATI = 0x877A,
+            BUMP_NUM_TEX_UNITS_ATI = 0x8777,
+            BUMP_ROT_MATRIX_SIZE_ATI = 0x8776,
+            BUMP_ENVMAP_ATI = 0x877B,
+            BUMP_TEX_UNITS_ATI = 0x8778,
+            DUDV_ATI = 0x8779,
+        }
+
+        public enum ATI_draw_buffers : uint
+        {
+            DRAW_BUFFER9_ATI = 0x882E,
+            DRAW_BUFFER10_ATI = 0x882F,
+            DRAW_BUFFER6_ATI = 0x882B,
+            DRAW_BUFFER4_ATI = 0x8829,
+            DRAW_BUFFER14_ATI = 0x8833,
+            DRAW_BUFFER3_ATI = 0x8828,
+            DRAW_BUFFER5_ATI = 0x882A,
+            DRAW_BUFFER0_ATI = 0x8825,
+            DRAW_BUFFER12_ATI = 0x8831,
+            DRAW_BUFFER11_ATI = 0x8830,
+            DRAW_BUFFER8_ATI = 0x882D,
+            DRAW_BUFFER15_ATI = 0x8834,
+            DRAW_BUFFER7_ATI = 0x882C,
+            DRAW_BUFFER13_ATI = 0x8832,
+            DRAW_BUFFER2_ATI = 0x8827,
+            DRAW_BUFFER1_ATI = 0x8826,
+            MAX_DRAW_BUFFERS_ATI = 0x8824,
+        }
+
+        public enum ColorMaterialFace : uint
+        {
+            BACK = DrawBufferMode.BACK,
+            FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
+            FRONT = DrawBufferMode.FRONT,
+        }
+
+        public enum GetTextureParameter : uint
+        {
+            TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX,
+            TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT,
+            TEXTURE_BORDER = 0x1005,
+            TEXTURE_HEIGHT = 0x1001,
+            TEXTURE_INTENSITY_SIZE = 0x8061,
+            TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX,
+            TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS,
+            TEXTURE_FILTER4_SIZE_SGIS = SGIS_texture_filter4.TEXTURE_FILTER4_SIZE_SGIS,
+            TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX,
+            TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX,
+            TEXTURE_PRIORITY = 0x8066,
+            TEXTURE_RED_SIZE = 0x805C,
+            TEXTURE_MIN_FILTER = TextureParameterName.TEXTURE_MIN_FILTER,
+            TEXTURE_4DSIZE_SGIS = SGIS_texture4D.TEXTURE_4DSIZE_SGIS,
+            TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS,
+            TEXTURE_WIDTH = 0x1000,
+            TEXTURE_BLUE_SIZE = 0x805E,
+            TEXTURE_WRAP_T = TextureParameterName.TEXTURE_WRAP_T,
+            TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS,
+            POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX,
+            TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX,
+            TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX,
+            TEXTURE_INTERNAL_FORMAT = 0x1003,
+            TEXTURE_LUMINANCE_SIZE = 0x8060,
+            TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX,
+            DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS,
+            TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX,
+            TEXTURE_COMPONENTS = 0x1003,
+            TEXTURE_COMPARE_OPERATOR_SGIX = SGIX_shadow.TEXTURE_COMPARE_OPERATOR_SGIX,
+            TEXTURE_LEQUAL_R_SGIX = SGIX_shadow.TEXTURE_LEQUAL_R_SGIX,
+            TEXTURE_GEQUAL_R_SGIX = SGIX_shadow.TEXTURE_GEQUAL_R_SGIX,
+            TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX,
+            DETAIL_TEXTURE_FUNC_POINTS_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_FUNC_POINTS_SGIS,
+            DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS,
+            TEXTURE_BORDER_COLOR = 0x1004,
+            SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX,
+            TEXTURE_MAG_FILTER = TextureParameterName.TEXTURE_MAG_FILTER,
+            TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS,
+            TEXTURE_GREEN_SIZE = 0x805D,
+            TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS,
+            TEXTURE_WRAP_S = TextureParameterName.TEXTURE_WRAP_S,
+            TEXTURE_RESIDENT = 0x8067,
+            TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX,
+            POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX,
+            DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS,
+            TEXTURE_DEPTH_EXT = EXT_texture3D.TEXTURE_DEPTH_EXT,
+            TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX,
+            TEXTURE_ALPHA_SIZE = 0x805F,
+            TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX,
+            QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS,
+            GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS,
+            SHARPEN_TEXTURE_FUNC_POINTS_SGIS = SGIS_sharpen_texture.SHARPEN_TEXTURE_FUNC_POINTS_SGIS,
+            TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX,
+        }
+
+        public enum ARB_texture_env_combine : uint
+        {
+            SOURCE2_RGB_ARB = 0x8582,
+            OPERAND0_ALPHA_ARB = 0x8598,
+            COMBINE_ARB = 0x8570,
+            SOURCE1_RGB_ARB = 0x8581,
+            ADD_SIGNED_ARB = 0x8574,
+            SUBTRACT_ARB = 0x84E7,
+            PRIMARY_COLOR_ARB = 0x8577,
+            SOURCE2_ALPHA_ARB = 0x858A,
+            OPERAND1_RGB_ARB = 0x8591,
+            OPERAND0_RGB_ARB = 0x8590,
+            OPERAND2_ALPHA_ARB = 0x859A,
+            CONSTANT_ARB = 0x8576,
+            SOURCE0_ALPHA_ARB = 0x8588,
+            INTERPOLATE_ARB = 0x8575,
+            PREVIOUS_ARB = 0x8578,
+            OPERAND2_RGB_ARB = 0x8592,
+            COMBINE_RGB_ARB = 0x8571,
+            SOURCE1_ALPHA_ARB = 0x8589,
+            SOURCE0_RGB_ARB = 0x8580,
+            COMBINE_ALPHA_ARB = 0x8572,
+            OPERAND1_ALPHA_ARB = 0x8599,
+            RGB_SCALE_ARB = 0x8573,
+        }
+
+        public enum SUN_global_alpha : uint
+        {
+            GLOBAL_ALPHA_SUN = 0x81D9,
+            GLOBAL_ALPHA_FACTOR_SUN = 0x81DA,
+        }
+
+        public enum NV_texture_shader : uint
+        {
+            DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA,
+            DS_SCALE_NV = 0x8710,
+            DSDT_MAG_INTENSITY_NV = 0x86DC,
+            SIGNED_HILO_NV = 0x86F9,
+            DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9,
+            OFFSET_TEXTURE_SCALE_NV = 0x86E2,
+            MAGNITUDE_SCALE_NV = 0x8712,
+            CULL_FRAGMENT_NV = 0x86E7,
+            OFFSET_TEXTURE_2D_SCALE_NV = NV_texture_shader.OFFSET_TEXTURE_SCALE_NV,
+            TEXTURE_DT_SIZE_NV = 0x871E,
+            OFFSET_TEXTURE_2D_NV = 0x86E8,
+            UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA,
+            VIBRANCE_SCALE_NV = 0x8713,
+            PREVIOUS_TEXTURE_INPUT_NV = 0x86E4,
+            SIGNED_LUMINANCE_NV = 0x8701,
+            DS_BIAS_NV = 0x8716,
+            SIGNED_RGB8_NV = 0x86FF,
+            DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1,
+            DSDT8_MAG8_INTENSITY8_NV = 0x870B,
+            VIBRANCE_BIAS_NV = 0x8719,
+            SIGNED_ALPHA8_NV = 0x8706,
+            LO_BIAS_NV = 0x8715,
+            UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB,
+            DOT_PRODUCT_NV = 0x86EC,
+            DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE,
+            SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D,
+            DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E,
+            DT_BIAS_NV = 0x8717,
+            SIGNED_LUMINANCE_ALPHA_NV = 0x8703,
+            OFFSET_TEXTURE_BIAS_NV = 0x86E3,
+            OFFSET_TEXTURE_2D_MATRIX_NV = NV_texture_shader.OFFSET_TEXTURE_MATRIX_NV,
+            HILO16_NV = 0x86F8,
+            TEXTURE_BORDER_VALUES_NV = 0x871A,
+            SIGNED_ALPHA_NV = 0x8705,
+            OFFSET_TEXTURE_MATRIX_NV = 0x86E1,
+            TEXTURE_SHADER_NV = 0x86DE,
+            OFFSET_TEXTURE_RECTANGLE_NV = 0x864C,
+            HI_BIAS_NV = 0x8714,
+            DSDT8_NV = 0x8709,
+            SHADER_CONSISTENT_NV = 0x86DD,
+            DSDT_MAG_NV = 0x86F6,
+            TEXTURE_LO_SIZE_NV = 0x871C,
+            DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2,
+            DSDT8_MAG8_NV = 0x870A,
+            SIGNED_RGBA8_NV = 0x86FC,
+            DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0,
+            CULL_MODES_NV = 0x86E0,
+            SIGNED_RGB_NV = 0x86FE,
+            OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D,
+            DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED,
+            CONST_EYE_NV = 0x86E5,
+            SIGNED_RGBA_NV = 0x86FB,
+            RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9,
+            SIGNED_INTENSITY8_NV = 0x8708,
+            SHADER_OPERATION_NV = 0x86DF,
+            PASS_THROUGH_NV = 0x86E6,
+            DSDT_NV = 0x86F5,
+            SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C,
+            OFFSET_TEXTURE_2D_BIAS_NV = NV_texture_shader.OFFSET_TEXTURE_BIAS_NV,
+            TEXTURE_MAG_SIZE_NV = 0x871F,
+            SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704,
+            SIGNED_HILO16_NV = 0x86FA,
+            SIGNED_INTENSITY_NV = 0x8707,
+            HILO_NV = 0x86F4,
+            DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3,
+            LO_SCALE_NV = 0x870F,
+            MAGNITUDE_BIAS_NV = 0x8718,
+            HI_SCALE_NV = 0x870E,
+            TEXTURE_DS_SIZE_NV = 0x871D,
+            DT_SCALE_NV = 0x8711,
+            SIGNED_LUMINANCE8_NV = 0x8702,
+            DSDT_MAG_VIB_NV = 0x86F7,
+            TEXTURE_HI_SIZE_NV = 0x871B,
+        }
+
+        public enum EXT_cull_vertex : uint
+        {
+            CULL_VERTEX_EXT = 0x81AA,
+            CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC,
+            CULL_VERTEX_EYE_POSITION_EXT = 0x81AB,
+        }
+
+        public enum ARB_texture_border_clamp : uint
+        {
+            CLAMP_TO_BORDER_ARB = 0x812D,
+        }
+
+        public enum SGIX_clipmap : uint
+        {
+            TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175,
+            NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E,
+            LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170,
+            TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172,
+            NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D,
+            TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174,
+            MAX_CLIPMAP_DEPTH_SGIX = 0x8177,
+            TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173,
+            TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176,
+            TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171,
+            LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F,
+            MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178,
+        }
+
+        public enum ConvolutionParameterEXT : uint
+        {
+            CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT,
+            CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT,
+            CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT,
+        }
+
+        public enum GetConvolutionParameter : uint
+        {
+            MAX_CONVOLUTION_WIDTH_EXT = EXT_convolution.MAX_CONVOLUTION_WIDTH_EXT,
+            CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT,
+            CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT,
+            CONVOLUTION_HEIGHT_EXT = EXT_convolution.CONVOLUTION_HEIGHT_EXT,
+            CONVOLUTION_WIDTH_EXT = EXT_convolution.CONVOLUTION_WIDTH_EXT,
+            MAX_CONVOLUTION_HEIGHT_EXT = EXT_convolution.MAX_CONVOLUTION_HEIGHT_EXT,
+            CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT,
+            CONVOLUTION_FORMAT_EXT = EXT_convolution.CONVOLUTION_FORMAT_EXT,
+        }
+
+        public enum SGIX_tag_sample_buffer : uint
+        {
+        }
+
+        public enum ClientAttribMask : uint
+        {
+            CLIENT_PIXEL_STORE_BIT = 0x00000001,
+            CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF,
+            CLIENT_VERTEX_ARRAY_BIT = 0x00000002,
+        }
+
+        public enum INGR_interlace_read : uint
+        {
+            INTERLACE_READ_INGR = 0x8568,
+        }
+
+        public enum ARB_texture_compression : uint
+        {
+            COMPRESSED_LUMINANCE_ARB = 0x84EA,
+            COMPRESSED_INTENSITY_ARB = 0x84EC,
+            TEXTURE_COMPRESSION_HINT_ARB = 0x84EF,
+            TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0,
+            COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3,
+            COMPRESSED_RGB_ARB = 0x84ED,
+            NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2,
+            COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB,
+            TEXTURE_COMPRESSED_ARB = 0x86A1,
+            COMPRESSED_ALPHA_ARB = 0x84E9,
+            COMPRESSED_RGBA_ARB = 0x84EE,
+        }
+
+        public enum TextureCoordName : uint
+        {
+            Q = 0x2003,
+            R = 0x2002,
+            S = 0x2000,
+            T = 0x2001,
+        }
+
+        public enum InterleavedArrayFormat : uint
+        {
+            T2F_C4UB_V3F = 0x2A29,
+            T2F_N3F_V3F = 0x2A2B,
+            T4F_V4F = 0x2A28,
+            T2F_V3F = 0x2A27,
+            V2F = 0x2A20,
+            T2F_C4F_N3F_V3F = 0x2A2C,
+            T4F_C4F_N3F_V4F = 0x2A2D,
+            T2F_C3F_V3F = 0x2A2A,
+            C3F_V3F = 0x2A24,
+            C4F_N3F_V3F = 0x2A26,
+            V3F = 0x2A21,
+            N3F_V3F = 0x2A25,
+            C4UB_V2F = 0x2A22,
+            C4UB_V3F = 0x2A23,
+        }
+
+        public enum NV_texture_shader3 : uint
+        {
+            DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859,
+            DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D,
+            SIGNED_HILO8_NV = 0x885F,
+            FORCE_BLUE_TO_ONE_NV = 0x8860,
+            OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857,
+            OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853,
+            DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858,
+            HILO8_NV = 0x885E,
+            OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850,
+            DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A,
+            OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856,
+            OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851,
+            OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855,
+            OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852,
+            OFFSET_HILO_TEXTURE_2D_NV = 0x8854,
+            DOT_PRODUCT_PASS_THROUGH_NV = 0x885B,
+            DOT_PRODUCT_TEXTURE_1D_NV = 0x885C,
+        }
+
+        public enum ARB_vertex_buffer_object : uint
+        {
+            NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897,
+            READ_ONLY_ARB = 0x88B8,
+            STATIC_DRAW_ARB = 0x88E4,
+            STATIC_COPY_ARB = 0x88E6,
+            BUFFER_MAP_POINTER_ARB = 0x88BD,
+            STREAM_COPY_ARB = 0x88E2,
+            STATIC_READ_ARB = 0x88E5,
+            READ_WRITE_ARB = 0x88BA,
+            TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A,
+            ARRAY_BUFFER_ARB = 0x8892,
+            BUFFER_SIZE_ARB = 0x8764,
+            BUFFER_ACCESS_ARB = 0x88BB,
+            DYNAMIC_DRAW_ARB = 0x88E8,
+            WRITE_ONLY_ARB = 0x88B9,
+            VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896,
+            FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D,
+            DYNAMIC_READ_ARB = 0x88E9,
+            DYNAMIC_COPY_ARB = 0x88EA,
+            STREAM_DRAW_ARB = 0x88E0,
+            WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E,
+            STREAM_READ_ARB = 0x88E1,
+            COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898,
+            BUFFER_MAPPED_ARB = 0x88BC,
+            INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899,
+            ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895,
+            EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B,
+            VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F,
+            ARRAY_BUFFER_BINDING_ARB = 0x8894,
+            SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C,
+            BUFFER_USAGE_ARB = 0x8765,
+            ELEMENT_ARRAY_BUFFER_ARB = 0x8893,
+        }
+
+        public enum SGIX_pixel_tiles : uint
+        {
+            PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F,
+            PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142,
+            PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143,
+            PIXEL_TILE_HEIGHT_SGIX = 0x8141,
+            PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145,
+            PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E,
+            PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144,
+            PIXEL_TILE_WIDTH_SGIX = 0x8140,
+        }
+
+        public enum NV_fragment_program2 : uint
+        {
+            MAX_PROGRAM_IF_DEPTH_NV = 0x88F6,
+            MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7,
+            MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5,
+            MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4,
+            MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8,
+        }
+
+        public enum EXT_vertex_weighting : uint
+        {
+            CURRENT_VERTEX_WEIGHT_EXT = 0x850B,
+            MODELVIEW0_MATRIX_EXT = GetPName.MODELVIEW_MATRIX,
+            VERTEX_WEIGHT_ARRAY_EXT = 0x850C,
+            MODELVIEW1_MATRIX_EXT = 0x8506,
+            VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E,
+            VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F,
+            MODELVIEW1_EXT = 0x850A,
+            VERTEX_WEIGHTING_EXT = 0x8509,
+            MODELVIEW0_EXT = MatrixMode.MODELVIEW,
+            MODELVIEW1_STACK_DEPTH_EXT = 0x8502,
+            VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510,
+            VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D,
+            MODELVIEW0_STACK_DEPTH_EXT = GetPName.MODELVIEW_STACK_DEPTH,
+        }
+
+        public enum ATI_pn_triangles : uint
+        {
+            PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4,
+            PN_TRIANGLES_POINT_MODE_ATI = 0x87F2,
+            PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8,
+            PN_TRIANGLES_ATI = 0x87F0,
+            PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7,
+            PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6,
+            PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3,
+            MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1,
+            PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5,
+        }
+
+        public enum SGIX_texture_scale_bias : uint
+        {
+            POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B,
+            POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179,
+            POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A,
+            POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C,
+        }
+
+        public enum SGIX_fog_offset : uint
+        {
+            FOG_OFFSET_VALUE_SGIX = 0x8199,
+            FOG_OFFSET_SGIX = 0x8198,
+        }
+
+        public enum EXT_texture : uint
+        {
+            LUMINANCE8_ALPHA8_EXT = 0x8045,
+            RGBA12_EXT = 0x805A,
+            INTENSITY12_EXT = 0x804C,
+            RGB16_EXT = 0x8054,
+            REPLACE_EXT = 0x8062,
+            RGB5_A1_EXT = 0x8057,
+            RGB5_EXT = 0x8050,
+            TEXTURE_INTENSITY_SIZE_EXT = 0x8061,
+            ALPHA12_EXT = 0x803D,
+            RGB4_EXT = 0x804F,
+            TEXTURE_LUMINANCE_SIZE_EXT = 0x8060,
+            RGBA16_EXT = 0x805B,
+            RGB8_EXT = 0x8051,
+            RGBA8_EXT = 0x8058,
+            RGB12_EXT = 0x8053,
+            LUMINANCE12_ALPHA12_EXT = 0x8047,
+            INTENSITY4_EXT = 0x804A,
+            INTENSITY8_EXT = 0x804B,
+            RGB10_A2_EXT = 0x8059,
+            RGB10_EXT = 0x8052,
+            LUMINANCE8_EXT = 0x8040,
+            TEXTURE_RED_SIZE_EXT = 0x805C,
+            LUMINANCE12_EXT = 0x8041,
+            PROXY_TEXTURE_2D_EXT = 0x8064,
+            LUMINANCE4_EXT = 0x803F,
+            INTENSITY16_EXT = 0x804D,
+            TEXTURE_GREEN_SIZE_EXT = 0x805D,
+            LUMINANCE16_ALPHA16_EXT = 0x8048,
+            TEXTURE_ALPHA_SIZE_EXT = 0x805F,
+            LUMINANCE16_EXT = 0x8042,
+            PROXY_TEXTURE_1D_EXT = 0x8063,
+            RGBA4_EXT = 0x8056,
+            INTENSITY_EXT = 0x8049,
+            RGBA2_EXT = 0x8055,
+            ALPHA16_EXT = 0x803E,
+            TEXTURE_TOO_LARGE_EXT = 0x8065,
+            ALPHA8_EXT = 0x803C,
+            ALPHA4_EXT = 0x803B,
+            LUMINANCE4_ALPHA4_EXT = 0x8043,
+            LUMINANCE6_ALPHA2_EXT = 0x8044,
+            TEXTURE_BLUE_SIZE_EXT = 0x805E,
+            RGB2_EXT = 0x804E,
+            LUMINANCE12_ALPHA4_EXT = 0x8046,
+        }
+
+        public enum IBM_rasterpos_clip : uint
+        {
+            RASTER_POSITION_UNCLIPPED_IBM = 0x19262,
+        }
+
+        public enum SGIS_texture_edge_clamp : uint
+        {
+            CLAMP_TO_EDGE_SGIS = 0x812F,
+            CLAMP_TO_EDGE = 0x812F,
+        }
+
+        public enum DataType : uint
+        {
+            DOUBLE = 0x140A,
+            DOUBLE_EXT = 0x140A,
+            UNSIGNED_INT = 0x1405,
+            _4_BYTES = 0x1409,
+            FLOAT = 0x1406,
+            UNSIGNED_SHORT = 0x1403,
+            SHORT = 0x1402,
+            BYTE = 0x1400,
+            _3_BYTES = 0x1408,
+            INT = 0x1404,
+            UNSIGNED_BYTE = 0x1401,
+            _2_BYTES = 0x1407,
+        }
+
+        public enum APPLE_fence : uint
+        {
+            DRAW_PIXELS_APPLE = 0x8A0A,
+            FENCE_APPLE = 0x8A0B,
+        }
+
+        public enum MeshMode1 : uint
+        {
+            LINE = PolygonMode.LINE,
+            POINT = PolygonMode.POINT,
+        }
+
+        public enum TextureTarget : uint
+        {
+            TEXTURE_1D = GetPName.TEXTURE_1D,
+            TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS,
+            TEXTURE_2D = GetPName.TEXTURE_2D,
+            TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS,
+            PROXY_TEXTURE_4D_SGIS = SGIS_texture4D.PROXY_TEXTURE_4D_SGIS,
+            PROXY_TEXTURE_2D = 0x8064,
+            TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
+            DETAIL_TEXTURE_2D_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_SGIS,
+            PROXY_TEXTURE_1D = 0x8063,
+            TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS,
+            TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS,
+            TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
+            PROXY_TEXTURE_3D_EXT = EXT_texture3D.PROXY_TEXTURE_3D_EXT,
+        }
+
+        public enum MeshMode2 : uint
+        {
+            FILL = PolygonMode.FILL,
+            LINE = PolygonMode.LINE,
+            POINT = PolygonMode.POINT,
+        }
+
+        public enum EXT_pixel_buffer_object : uint
+        {
+            PIXEL_UNPACK_BUFFER_EXT = 0x88EC,
+            PIXEL_PACK_BUFFER_EXT = 0x88EB,
+            PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF,
+            PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED,
+        }
+
+        public enum EXT_framebuffer_multisample : uint
+        {
+            RENDERBUFFER_SAMPLES_EXT = 0x8CAB,
+        }
+
+        public enum ATI_texture_mirror_once : uint
+        {
+            MIRROR_CLAMP_ATI = 0x8742,
+            MIRROR_CLAMP_TO_EDGE_ATI = 0x8743,
+        }
+
+        public enum SGI_color_table : uint
+        {
+            COLOR_TABLE_SGI = 0x80D0,
+            COLOR_TABLE_FORMAT_SGI = 0x80D8,
+            COLOR_TABLE_SCALE = 0x80D6,
+            COLOR_TABLE_SCALE_SGI = 0x80D6,
+            PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5,
+            COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF,
+            COLOR_TABLE_WIDTH_SGI = 0x80D9,
+            COLOR_TABLE_BIAS = 0x80D7,
+            COLOR_TABLE_BLUE_SIZE = 0x80DC,
+            POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2,
+            COLOR_TABLE_FORMAT = 0x80D8,
+            PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
+            PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4,
+            PROXY_COLOR_TABLE_SGI = 0x80D3,
+            COLOR_TABLE_GREEN_SIZE = 0x80DB,
+            PROXY_COLOR_TABLE = 0x80D3,
+            COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE,
+            COLOR_TABLE_ALPHA_SIZE = 0x80DD,
+            POST_CONVOLUTION_COLOR_TABLE = 0x80D1,
+            COLOR_TABLE_BIAS_SGI = 0x80D7,
+            COLOR_TABLE_WIDTH = 0x80D9,
+            POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2,
+            COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC,
+            COLOR_TABLE = 0x80D0,
+            PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
+            COLOR_TABLE_RED_SIZE_SGI = 0x80DA,
+            COLOR_TABLE_LUMINANCE_SIZE = 0x80DE,
+            POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1,
+            COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB,
+            COLOR_TABLE_RED_SIZE = 0x80DA,
+            COLOR_TABLE_INTENSITY_SIZE = 0x80DF,
+            COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD,
+        }
+
+        public enum SGIS_detail_texture : uint
+        {
+            DETAIL_TEXTURE_MODE_SGIS = 0x809B,
+            DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096,
+            DETAIL_TEXTURE_LEVEL_SGIS = 0x809A,
+            DETAIL_TEXTURE_2D_SGIS = 0x8095,
+            LINEAR_DETAIL_SGIS = 0x8097,
+            DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C,
+            LINEAR_DETAIL_ALPHA_SGIS = 0x8098,
+            LINEAR_DETAIL_COLOR_SGIS = 0x8099,
+        }
+
+        public enum HP_occlusion_test : uint
+        {
+            OCCLUSION_TEST_HP = 0x8165,
+            OCCLUSION_TEST_RESULT_HP = 0x8166,
+        }
+
+        public enum ATI_texture_float : uint
+        {
+            ALPHA_FLOAT32_ATI = 0x8816,
+            INTENSITY_FLOAT32_ATI = 0x8817,
+            LUMINANCE_FLOAT32_ATI = 0x8818,
+            LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F,
+            ALPHA_FLOAT16_ATI = 0x881C,
+            LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819,
+            RGBA_FLOAT16_ATI = 0x881A,
+            RGBA_FLOAT32_ATI = 0x8814,
+            LUMINANCE_FLOAT16_ATI = 0x881E,
+            RGB_FLOAT32_ATI = 0x8815,
+            INTENSITY_FLOAT16_ATI = 0x881D,
+            RGB_FLOAT16_ATI = 0x881B,
+        }
+
+        public enum SGIX_texture_multi_buffer : uint
+        {
+            TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E,
+        }
+
+        public enum _3DFX_tbuffer : uint
+        {
+        }
+
+        public enum EXT_vertex_shader : uint
+        {
+            OP_INDEX_EXT = 0x8782,
+            OP_MOV_EXT = 0x8799,
+            OP_MULTIPLY_MATRIX_EXT = 0x8798,
+            VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF,
+            VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4,
+            OUTPUT_FOG_EXT = 0x87BD,
+            Y_EXT = 0x87D6,
+            OP_ROUND_EXT = 0x8790,
+            OUTPUT_TEXTURE_COORD28_EXT = 0x87B9,
+            INVARIANT_EXT = 0x87C2,
+            MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6,
+            OP_POWER_EXT = 0x8793,
+            CURRENT_VERTEX_EXT = 0x87E2,
+            OUTPUT_TEXTURE_COORD1_EXT = 0x879E,
+            OUTPUT_TEXTURE_COORD29_EXT = 0x87BA,
+            LOCAL_EXT = 0x87C4,
+            OUTPUT_TEXTURE_COORD4_EXT = 0x87A1,
+            OUTPUT_TEXTURE_COORD20_EXT = 0x87B1,
+            VARIANT_ARRAY_POINTER_EXT = 0x87E9,
+            Z_EXT = 0x87D7,
+            VARIANT_ARRAY_STRIDE_EXT = 0x87E6,
+            VARIANT_VALUE_EXT = 0x87E4,
+            MVP_MATRIX_EXT = 0x87E3,
+            VERTEX_SHADER_BINDING_EXT = 0x8781,
+            OUTPUT_TEXTURE_COORD19_EXT = 0x87B0,
+            INVARIANT_VALUE_EXT = 0x87EA,
+            OUTPUT_TEXTURE_COORD21_EXT = 0x87B2,
+            MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8,
+            OUTPUT_TEXTURE_COORD3_EXT = 0x87A0,
+            OUTPUT_TEXTURE_COORD10_EXT = 0x87A7,
+            OP_MUL_EXT = 0x8786,
+            NEGATIVE_ONE_EXT = 0x87DF,
+            OP_CROSS_PRODUCT_EXT = 0x8797,
+            VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2,
+            OUTPUT_TEXTURE_COORD18_EXT = 0x87AF,
+            OP_NEGATE_EXT = 0x8783,
+            OUTPUT_TEXTURE_COORD6_EXT = 0x87A3,
+            VERTEX_SHADER_INVARIANTS_EXT = 0x87D1,
+            OUTPUT_TEXTURE_COORD11_EXT = 0x87A8,
+            W_EXT = 0x87D8,
+            OP_SET_LT_EXT = 0x878D,
+            ONE_EXT = 0x87DE,
+            VARIANT_ARRAY_EXT = 0x87E8,
+            OUTPUT_COLOR1_EXT = 0x879C,
+            OUTPUT_TEXTURE_COORD13_EXT = 0x87AA,
+            OUTPUT_TEXTURE_COORD24_EXT = 0x87B5,
+            X_EXT = 0x87D5,
+            ZERO_EXT = 0x87DD,
+            LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED,
+            SCALAR_EXT = 0x87BE,
+            OUTPUT_TEXTURE_COORD30_EXT = 0x87BB,
+            VARIANT_ARRAY_TYPE_EXT = 0x87E7,
+            VERTEX_SHADER_VARIANTS_EXT = 0x87D0,
+            OUTPUT_TEXTURE_COORD5_EXT = 0x87A2,
+            NEGATIVE_W_EXT = 0x87DC,
+            OUTPUT_TEXTURE_COORD25_EXT = 0x87B6,
+            MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD,
+            OP_FLOOR_EXT = 0x878F,
+            NEGATIVE_Y_EXT = 0x87DA,
+            MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7,
+            OUTPUT_TEXTURE_COORD8_EXT = 0x87A5,
+            OP_RECIP_EXT = 0x8794,
+            OUTPUT_TEXTURE_COORD31_EXT = 0x87BC,
+            OUTPUT_TEXTURE_COORD14_EXT = 0x87AB,
+            NEGATIVE_X_EXT = 0x87D9,
+            MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5,
+            VARIANT_DATATYPE_EXT = 0x87E5,
+            OUTPUT_VERTEX_EXT = 0x879A,
+            OP_ADD_EXT = 0x8787,
+            OUTPUT_TEXTURE_COORD0_EXT = 0x879D,
+            OUTPUT_TEXTURE_COORD15_EXT = 0x87AC,
+            OP_MADD_EXT = 0x8788,
+            OP_DOT3_EXT = 0x8784,
+            MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE,
+            OUTPUT_TEXTURE_COORD7_EXT = 0x87A4,
+            LOCAL_CONSTANT_EXT = 0x87C3,
+            VECTOR_EXT = 0x87BF,
+            VERTEX_SHADER_EXT = 0x8780,
+            NORMALIZED_RANGE_EXT = 0x87E0,
+            VARIANT_EXT = 0x87C1,
+            OUTPUT_TEXTURE_COORD26_EXT = 0x87B7,
+            OP_MAX_EXT = 0x878A,
+            OP_CLAMP_EXT = 0x878E,
+            INVARIANT_DATATYPE_EXT = 0x87EB,
+            MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9,
+            OUTPUT_TEXTURE_COORD22_EXT = 0x87B3,
+            OP_SET_GE_EXT = 0x878C,
+            OP_FRAC_EXT = 0x8789,
+            VERTEX_SHADER_LOCALS_EXT = 0x87D3,
+            MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA,
+            LOCAL_CONSTANT_VALUE_EXT = 0x87EC,
+            OUTPUT_TEXTURE_COORD27_EXT = 0x87B8,
+            NEGATIVE_Z_EXT = 0x87DB,
+            OP_RECIP_SQRT_EXT = 0x8795,
+            MATRIX_EXT = 0x87C0,
+            OP_EXP_BASE_2_EXT = 0x8791,
+            OUTPUT_TEXTURE_COORD16_EXT = 0x87AD,
+            OUTPUT_TEXTURE_COORD23_EXT = 0x87B4,
+            OUTPUT_COLOR0_EXT = 0x879B,
+            OP_MIN_EXT = 0x878B,
+            OP_DOT4_EXT = 0x8785,
+            OUTPUT_TEXTURE_COORD12_EXT = 0x87A9,
+            OP_SUB_EXT = 0x8796,
+            MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB,
+            MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC,
+            OUTPUT_TEXTURE_COORD2_EXT = 0x879F,
+            OUTPUT_TEXTURE_COORD17_EXT = 0x87AE,
+            OP_LOG_BASE_2_EXT = 0x8792,
+            OUTPUT_TEXTURE_COORD9_EXT = 0x87A6,
+            FULL_RANGE_EXT = 0x87E1,
+        }
+
+        public enum EXT_texture_sRGB : uint
+        {
+            COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F,
+            SRGB8_EXT = 0x8C41,
+            SLUMINANCE8_ALPHA8_EXT = 0x8C45,
+            COMPRESSED_SRGB_ALPHA_EXT = 0x8C49,
+            SLUMINANCE_EXT = 0x8C46,
+            COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C,
+            SLUMINANCE_ALPHA_EXT = 0x8C44,
+            COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D,
+            SRGB8_ALPHA8_EXT = 0x8C43,
+            SRGB_ALPHA_EXT = 0x8C42,
+            SRGB_EXT = 0x8C40,
+            COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E,
+            SLUMINANCE8_EXT = 0x8C47,
+            COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B,
+            COMPRESSED_SRGB_EXT = 0x8C48,
+            COMPRESSED_SLUMINANCE_EXT = 0x8C4A,
+        }
+
+        public enum ClipPlaneName : uint
+        {
+            CLIP_PLANE3 = 0x3003,
+            CLIP_PLANE2 = 0x3002,
+            CLIP_PLANE5 = 0x3005,
+            CLIP_PLANE1 = 0x3001,
+            CLIP_PLANE0 = 0x3000,
+            CLIP_PLANE4 = 0x3004,
+        }
+
+        public enum NormalPointerType : uint
+        {
+            DOUBLE = DataType.DOUBLE,
+            BYTE = DataType.BYTE,
+            SHORT = DataType.SHORT,
+            INT = DataType.INT,
+            FLOAT = DataType.FLOAT,
+        }
+
+        public enum ARB_texture_cube_map : uint
+        {
+            TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517,
+            TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516,
+            TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518,
+            TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515,
+            TEXTURE_CUBE_MAP_ARB = 0x8513,
+            TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A,
+            MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C,
+            REFLECTION_MAP_ARB = 0x8512,
+            TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514,
+            NORMAL_MAP_ARB = 0x8511,
+            PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B,
+            TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519,
+        }
+
+        public enum SGIX_impact_pixel_texture : uint
+        {
+            PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188,
+            PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185,
+            PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184,
+            PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186,
+            PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A,
+            PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187,
+            PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189,
+        }
+
+        public enum EXT_cmyka : uint
+        {
+            UNPACK_CMYK_HINT_EXT = 0x800F,
+            PACK_CMYK_HINT_EXT = 0x800E,
+            CMYKA_EXT = 0x800D,
+            CMYK_EXT = 0x800C,
+        }
+
+        public enum StencilFunction : uint
+        {
+            NEVER = AlphaFunction.NEVER,
+            GEQUAL = AlphaFunction.GEQUAL,
+            GREATER = AlphaFunction.GREATER,
+            ALWAYS = AlphaFunction.ALWAYS,
+            LEQUAL = AlphaFunction.LEQUAL,
+            NOTEQUAL = AlphaFunction.NOTEQUAL,
+            EQUAL = AlphaFunction.EQUAL,
+            LESS = AlphaFunction.LESS,
+        }
+
+        public enum SGIX_icc_texture : uint
+        {
+            RGBA_ICC_SGIX = 0x8461,
+            INTENSITY_ICC_SGIX = 0x8464,
+            ALPHA_ICC_SGIX = 0x8462,
+            LUMINANCE_ICC_SGIX = 0x8463,
+            LUMINANCE16_ICC_SGIX = 0x8469,
+            R5_G6_B5_ICC_SGIX = 0x8466,
+            ALPHA16_ICC_SGIX = 0x8468,
+            INTENSITY16_ICC_SGIX = 0x846A,
+            RGB_ICC_SGIX = 0x8460,
+            LUMINANCE_ALPHA_ICC_SGIX = 0x8465,
+            R5_G6_B5_A8_ICC_SGIX = 0x8467,
+            LUMINANCE16_ALPHA8_ICC_SGIX = 0x846B,
+        }
+
+        public enum VERSION_1_2 : uint
+        {
+            TEXTURE_BASE_LEVEL = 0x813C,
+            UNSIGNED_SHORT_5_6_5_REV = 0x8364,
+            PACK_IMAGE_HEIGHT = 0x806C,
+            MAX_ELEMENTS_INDICES = 0x80E9,
+            UNPACK_SKIP_IMAGES = 0x806D,
+            LIGHT_MODEL_COLOR_CONTROL = 0x81F8,
+            UNSIGNED_INT_8_8_8_8_REV = 0x8367,
+            SMOOTH_LINE_WIDTH_RANGE = 0x0B22,
+            TEXTURE_WRAP_R = 0x8072,
+            PACK_SKIP_IMAGES = 0x806B,
+            UNSIGNED_BYTE_2_3_3_REV = 0x8362,
+            UNSIGNED_SHORT_5_6_5 = 0x8363,
+            UNSIGNED_INT_8_8_8_8 = 0x8035,
+            PROXY_TEXTURE_3D = 0x8070,
+            SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13,
+            UNSIGNED_SHORT_5_5_5_1 = 0x8034,
+            TEXTURE_MAX_LOD = 0x813B,
+            UNSIGNED_BYTE_3_3_2 = 0x8032,
+            TEXTURE_MAX_LEVEL = 0x813D,
+            BGRA = 0x80E1,
+            SEPARATE_SPECULAR_COLOR = 0x81FA,
+            ALIASED_POINT_SIZE_RANGE = 0x846D,
+            SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23,
+            SINGLE_COLOR = 0x81F9,
+            RESCALE_NORMAL = 0x803A,
+            UNSIGNED_INT_10_10_10_2 = 0x8036,
+            ALIASED_LINE_WIDTH_RANGE = 0x846E,
+            UNPACK_IMAGE_HEIGHT = 0x806E,
+            UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
+            TEXTURE_MIN_LOD = 0x813A,
+            MAX_3D_TEXTURE_SIZE = 0x8073,
+            TEXTURE_3D = 0x806F,
+            SMOOTH_POINT_SIZE_RANGE = 0x0B12,
+            MAX_ELEMENTS_VERTICES = 0x80E8,
+            TEXTURE_DEPTH = 0x8071,
+            UNSIGNED_INT_2_10_10_10_REV = 0x8368,
+            TEXTURE_BINDING_3D = 0x806A,
+            UNSIGNED_SHORT_4_4_4_4 = 0x8033,
+            UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
+            BGR = 0x80E0,
+            CLAMP_TO_EDGE = 0x812F,
+        }
+
+        public enum NV_vertex_program1_1 : uint
+        {
+        }
+
+        public enum EXT_compiled_vertex_array : uint
+        {
+            ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9,
+            ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8,
+        }
+
+        public enum MESAX_texture_stack : uint
+        {
+            TEXTURE_1D_STACK_MESAX = 0x8759,
+            PROXY_TEXTURE_2D_STACK_MESAX = 0x875C,
+            TEXTURE_2D_STACK_MESAX = 0x875A,
+            TEXTURE_1D_STACK_BINDING_MESAX = 0x875D,
+            PROXY_TEXTURE_1D_STACK_MESAX = 0x875B,
+            TEXTURE_2D_STACK_BINDING_MESAX = 0x875E,
+        }
+
+        public enum EXT_timer_query : uint
+        {
+            TIME_ELAPSED_EXT = 0x88BF,
+        }
+
+    }
+    #endregion
+
+}
+
diff --git a/Source/OpenGL/OpenGL/Bindings/GLExtensions.cs b/Source/OpenGL/OpenGL/Bindings/GLExtensions.cs
new file mode 100644
index 00000000..2e2ddee7
--- /dev/null
+++ b/Source/OpenGL/OpenGL/Bindings/GLExtensions.cs
@@ -0,0 +1,42776 @@
+#region License
+//THIS FILE IS AUTOMATICALLY GENERATED
+//DO NOT EDIT BY HAND!!
+//See license.txt for license info
+#endregion
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace OpenTK.OpenGL
+{
+    #region Types
+    using GLsizeiptrARB = System.IntPtr;
+    using GLintptrARB = System.IntPtr;
+    using GLhandleARB = System.Int32;
+    using GLhalfARB = System.Int16;
+    using GLhalfNV = System.Int16;
+    using GLcharARB = System.Char;
+    using GLsizei = System.Int32;
+    using GLsizeiptr = System.IntPtr;
+    using GLintptr = System.IntPtr;
+    using GLenum = System.Int32;
+    using GLboolean = System.Boolean;
+    using GLbitfield = System.Int32;
+    using GLchar = System.Char;
+    using GLbyte = System.Byte;
+    using GLubyte = System.Byte;
+    using GLshort = System.Int16;
+    using GLushort = System.Int16;
+    using GLint = System.Int32;
+    using GLuint = System.Int32;
+    using GLfloat = System.Single;
+    using GLclampf = System.Single;
+    using GLdouble = System.Double;
+    using GLclampd = System.Double;
+    using GLstring = System.String;
+    using GLint64EXT = System.Int64;
+    using GLuint64EXT = System.Int64;
+    using GLint64 = System.Int64;
+    using GLuint64 = System.Int64;
+    #endregion
+
+    static public partial class GL
+    {
+        static public class Extensions
+        {
+        #region Function signatures
+
+        public static class Delegates
+        {
+            public delegate void ActiveTextureARB(GLenum texture);
+            public delegate void ClientActiveTextureARB(GLenum texture);
+            public delegate void MultiTexCoord1dARB(GLenum target, GLdouble s);
+            public delegate void MultiTexCoord1dvARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord1fARB(GLenum target, GLfloat s);
+            public delegate void MultiTexCoord1fvARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord1iARB(GLenum target, GLint s);
+            public delegate void MultiTexCoord1ivARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord1sARB(GLenum target, GLshort s);
+            public delegate void MultiTexCoord1svARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t);
+            public delegate void MultiTexCoord2dvARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t);
+            public delegate void MultiTexCoord2fvARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord2iARB(GLenum target, GLint s, GLint t);
+            public delegate void MultiTexCoord2ivARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord2sARB(GLenum target, GLshort s, GLshort t);
+            public delegate void MultiTexCoord2svARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r);
+            public delegate void MultiTexCoord3dvARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r);
+            public delegate void MultiTexCoord3fvARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r);
+            public delegate void MultiTexCoord3ivARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r);
+            public delegate void MultiTexCoord3svARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+            public delegate void MultiTexCoord4dvARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+            public delegate void MultiTexCoord4fvARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q);
+            public delegate void MultiTexCoord4ivARB_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
+            public delegate void MultiTexCoord4svARB_(GLenum target, IntPtr v);
+            public delegate void LoadTransposeMatrixfARB_(IntPtr m);
+            public delegate void LoadTransposeMatrixdARB_(IntPtr m);
+            public delegate void MultTransposeMatrixfARB_(IntPtr m);
+            public delegate void MultTransposeMatrixdARB_(IntPtr m);
+            public delegate void SampleCoverageARB(GLclampf value, Enums.Boolean invert);
+            public delegate void CompressedTexImage3DARB_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data);
+            public delegate void CompressedTexImage2DARB_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data);
+            public delegate void CompressedTexImage1DARB_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data);
+            public delegate void CompressedTexSubImage3DARB_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data);
+            public delegate void CompressedTexSubImage2DARB_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data);
+            public delegate void CompressedTexSubImage1DARB_(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data);
+            public delegate void GetCompressedTexImageARB_(Enums.TextureTarget target, GLint level, IntPtr img);
+            public delegate void PointParameterfARB(GLenum pname, GLfloat param);
+            public delegate void PointParameterfvARB_(GLenum pname, IntPtr parameters);
+            public delegate void WeightbvARB_(GLint size, IntPtr weights);
+            public delegate void WeightsvARB_(GLint size, IntPtr weights);
+            public delegate void WeightivARB_(GLint size, IntPtr weights);
+            public delegate void WeightfvARB_(GLint size, IntPtr weights);
+            public delegate void WeightdvARB_(GLint size, IntPtr weights);
+            public delegate void WeightubvARB_(GLint size, IntPtr weights);
+            public delegate void WeightusvARB_(GLint size, IntPtr weights);
+            public delegate void WeightuivARB_(GLint size, IntPtr weights);
+            public delegate void WeightPointerARB_(GLint size, GLenum type, GLsizei stride, IntPtr pointer);
+            public delegate void VertexBlendARB(GLint count);
+            public delegate void CurrentPaletteMatrixARB(GLint index);
+            public delegate void MatrixIndexubvARB_(GLint size, IntPtr indices);
+            public delegate void MatrixIndexusvARB_(GLint size, IntPtr indices);
+            public delegate void MatrixIndexuivARB_(GLint size, IntPtr indices);
+            public delegate void MatrixIndexPointerARB_(GLint size, GLenum type, GLsizei stride, IntPtr pointer);
+            public delegate void WindowPos2dARB(GLdouble x, GLdouble y);
+            public delegate void WindowPos2dvARB_(IntPtr v);
+            public delegate void WindowPos2fARB(GLfloat x, GLfloat y);
+            public delegate void WindowPos2fvARB_(IntPtr v);
+            public delegate void WindowPos2iARB(GLint x, GLint y);
+            public delegate void WindowPos2ivARB_(IntPtr v);
+            public delegate void WindowPos2sARB(GLshort x, GLshort y);
+            public delegate void WindowPos2svARB_(IntPtr v);
+            public delegate void WindowPos3dARB(GLdouble x, GLdouble y, GLdouble z);
+            public delegate void WindowPos3dvARB_(IntPtr v);
+            public delegate void WindowPos3fARB(GLfloat x, GLfloat y, GLfloat z);
+            public delegate void WindowPos3fvARB_(IntPtr v);
+            public delegate void WindowPos3iARB(GLint x, GLint y, GLint z);
+            public delegate void WindowPos3ivARB_(IntPtr v);
+            public delegate void WindowPos3sARB(GLshort x, GLshort y, GLshort z);
+            public delegate void WindowPos3svARB_(IntPtr v);
+            public delegate void VertexAttrib1dARB(GLuint index, GLdouble x);
+            public delegate void VertexAttrib1dvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib1fARB(GLuint index, GLfloat x);
+            public delegate void VertexAttrib1fvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib1sARB(GLuint index, GLshort x);
+            public delegate void VertexAttrib1svARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y);
+            public delegate void VertexAttrib2dvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y);
+            public delegate void VertexAttrib2fvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib2sARB(GLuint index, GLshort x, GLshort y);
+            public delegate void VertexAttrib2svARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+            public delegate void VertexAttrib3dvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void VertexAttrib3fvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z);
+            public delegate void VertexAttrib3svARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4NbvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4NivARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4NsvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+            public delegate void VertexAttrib4NubvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4NuivARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4NusvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4bvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+            public delegate void VertexAttrib4dvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void VertexAttrib4fvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4ivARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+            public delegate void VertexAttrib4svARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4ubvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4uivARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4usvARB_(GLuint index, IntPtr v);
+            public delegate void VertexAttribPointerARB_(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer);
+            public delegate void EnableVertexAttribArrayARB(GLuint index);
+            public delegate void DisableVertexAttribArrayARB(GLuint index);
+            public delegate void ProgramStringARB_(GLenum target, GLenum format, GLsizei len, IntPtr @string);
+            public delegate void BindProgramARB(GLenum target, GLuint program);
+            public delegate void DeleteProgramsARB_(GLsizei n, IntPtr programs);
+            public delegate void GenProgramsARB_(GLsizei n, IntPtr programs);
+            public delegate void ProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+            public delegate void ProgramEnvParameter4dvARB_(GLenum target, GLuint index, IntPtr parameters);
+            public delegate void ProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void ProgramEnvParameter4fvARB_(GLenum target, GLuint index, IntPtr parameters);
+            public delegate void ProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+            public delegate void ProgramLocalParameter4dvARB_(GLenum target, GLuint index, IntPtr parameters);
+            public delegate void ProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void ProgramLocalParameter4fvARB_(GLenum target, GLuint index, IntPtr parameters);
+            public delegate void GetProgramEnvParameterdvARB_(GLenum target, GLuint index, IntPtr parameters);
+            public delegate void GetProgramEnvParameterfvARB_(GLenum target, GLuint index, IntPtr parameters);
+            public delegate void GetProgramLocalParameterdvARB_(GLenum target, GLuint index, IntPtr parameters);
+            public delegate void GetProgramLocalParameterfvARB_(GLenum target, GLuint index, IntPtr parameters);
+            public delegate void GetProgramivARB_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetProgramStringARB_(GLenum target, GLenum pname, IntPtr @string);
+            public delegate void GetVertexAttribdvARB_(GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetVertexAttribfvARB_(GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetVertexAttribivARB_(GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetVertexAttribPointervARB_(GLuint index, GLenum pname, IntPtr pointer);
+            public delegate GLboolean IsProgramARB(GLuint program);
+            public delegate void BindBufferARB(GLenum target, GLuint buffer);
+            public delegate void DeleteBuffersARB_(GLsizei n, IntPtr buffers);
+            public delegate void GenBuffersARB_(GLsizei n, IntPtr buffers);
+            public delegate GLboolean IsBufferARB(GLuint buffer);
+            public delegate void BufferDataARB_(GLenum target, GLsizeiptrARB size, IntPtr data, GLenum usage);
+            public delegate void BufferSubDataARB_(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data);
+            public delegate void GetBufferSubDataARB_(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data);
+            public delegate IntPtr MapBufferARB(GLenum target, GLenum access);
+            public delegate GLboolean UnmapBufferARB(GLenum target);
+            public delegate void GetBufferParameterivARB_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetBufferPointervARB_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GenQueriesARB_(GLsizei n, IntPtr ids);
+            public delegate void DeleteQueriesARB_(GLsizei n, IntPtr ids);
+            public delegate GLboolean IsQueryARB(GLuint id);
+            public delegate void BeginQueryARB(Enums.ARB_occlusion_query target, GLuint id);
+            public delegate void EndQueryARB(Enums.ARB_occlusion_query target);
+            public delegate void GetQueryivARB_(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, IntPtr parameters);
+            public delegate void GetQueryObjectivARB_(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters);
+            public delegate void GetQueryObjectuivARB_(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters);
+            public delegate void DeleteObjectARB(GLhandleARB obj);
+            public delegate GLhandleARB GetHandleARB(Enums.ARB_shader_objects pname);
+            public delegate void DetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj);
+            public delegate GLhandleARB CreateShaderObjectARB(Enums.ARB_shader_objects shaderType);
+            public delegate void ShaderSourceARB_(GLhandleARB shaderObj, GLsizei count, string @string, IntPtr length);
+            public delegate void CompileShaderARB(GLhandleARB shaderObj);
+            public delegate GLhandleARB CreateProgramObjectARB();
+            public delegate void AttachObjectARB(GLhandleARB containerObj, GLhandleARB obj);
+            public delegate void LinkProgramARB(GLhandleARB programObj);
+            public delegate void UseProgramObjectARB(GLhandleARB programObj);
+            public delegate void ValidateProgramARB(GLhandleARB programObj);
+            public delegate void Uniform1fARB(GLint location, GLfloat v0);
+            public delegate void Uniform2fARB(GLint location, GLfloat v0, GLfloat v1);
+            public delegate void Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+            public delegate void Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+            public delegate void Uniform1iARB(GLint location, GLint v0);
+            public delegate void Uniform2iARB(GLint location, GLint v0, GLint v1);
+            public delegate void Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2);
+            public delegate void Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+            public delegate void Uniform1fvARB_(GLint location, GLsizei count, IntPtr value);
+            public delegate void Uniform2fvARB_(GLint location, GLsizei count, IntPtr value);
+            public delegate void Uniform3fvARB_(GLint location, GLsizei count, IntPtr value);
+            public delegate void Uniform4fvARB_(GLint location, GLsizei count, IntPtr value);
+            public delegate void Uniform1ivARB_(GLint location, GLsizei count, IntPtr value);
+            public delegate void Uniform2ivARB_(GLint location, GLsizei count, IntPtr value);
+            public delegate void Uniform3ivARB_(GLint location, GLsizei count, IntPtr value);
+            public delegate void Uniform4ivARB_(GLint location, GLsizei count, IntPtr value);
+            public delegate void UniformMatrix2fvARB_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix3fvARB_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void UniformMatrix4fvARB_(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value);
+            public delegate void GetObjectParameterfvARB_(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters);
+            public delegate void GetObjectParameterivARB_(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters);
+            public delegate void GetInfoLogARB_(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder infoLog);
+            public delegate void GetAttachedObjectsARB_(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, IntPtr obj);
+            public delegate GLint GetUniformLocationARB(GLhandleARB programObj, string name);
+            public delegate void GetActiveUniformARB_(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name);
+            public delegate void GetUniformfvARB_(GLhandleARB programObj, GLint location, IntPtr parameters);
+            public delegate void GetUniformivARB_(GLhandleARB programObj, GLint location, IntPtr parameters);
+            public delegate void GetShaderSourceARB_(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder source);
+            public delegate void BindAttribLocationARB(GLhandleARB programObj, GLuint index, string name);
+            public delegate void GetActiveAttribARB_(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name);
+            public delegate GLint GetAttribLocationARB(GLhandleARB programObj, string name);
+            public delegate void DrawBuffersARB_(GLsizei n, IntPtr bufs);
+            public delegate void ClampColorARB(GLenum target, GLenum clamp);
+            public delegate void BlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+            public delegate void PolygonOffsetEXT(GLfloat factor, GLfloat bias);
+            public delegate void TexImage3DEXT_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
+            public delegate void TexSubImage3DEXT_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
+            public delegate void GetTexFilterFuncSGIS_(Enums.TextureTarget target, GLenum filter, IntPtr weights);
+            public delegate void TexFilterFuncSGIS_(Enums.TextureTarget target, GLenum filter, GLsizei n, IntPtr weights);
+            public delegate void TexSubImage1DEXT_(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
+            public delegate void TexSubImage2DEXT_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
+            public delegate void CopyTexImage1DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border);
+            public delegate void CopyTexImage2DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+            public delegate void CopyTexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+            public delegate void CopyTexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+            public delegate void CopyTexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+            public delegate void GetHistogramEXT_(Enums.HistogramTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
+            public delegate void GetHistogramParameterfvEXT_(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters);
+            public delegate void GetHistogramParameterivEXT_(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters);
+            public delegate void GetMinmaxEXT_(Enums.MinmaxTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values);
+            public delegate void GetMinmaxParameterfvEXT_(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters);
+            public delegate void GetMinmaxParameterivEXT_(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters);
+            public delegate void HistogramEXT(Enums.HistogramTargetEXT target, GLsizei width, Enums.PixelInternalFormat internalformat, Enums.Boolean sink);
+            public delegate void MinmaxEXT(Enums.MinmaxTargetEXT target, Enums.PixelInternalFormat internalformat, Enums.Boolean sink);
+            public delegate void ResetHistogramEXT(Enums.HistogramTargetEXT target);
+            public delegate void ResetMinmaxEXT(Enums.MinmaxTargetEXT target);
+            public delegate void ConvolutionFilter1DEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image);
+            public delegate void ConvolutionFilter2DEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image);
+            public delegate void ConvolutionParameterfEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat parameters);
+            public delegate void ConvolutionParameterfvEXT_(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters);
+            public delegate void ConvolutionParameteriEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint parameters);
+            public delegate void ConvolutionParameterivEXT_(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters);
+            public delegate void CopyConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
+            public delegate void CopyConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+            public delegate void GetConvolutionFilterEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr image);
+            public delegate void GetConvolutionParameterfvEXT_(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters);
+            public delegate void GetConvolutionParameterivEXT_(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters);
+            public delegate void GetSeparableFilterEXT_(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, IntPtr span);
+            public delegate void SeparableFilter2DEXT_(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column);
+            public delegate void ColorTableSGI_(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table);
+            public delegate void ColorTableParameterfvSGI_(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters);
+            public delegate void ColorTableParameterivSGI_(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters);
+            public delegate void CopyColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
+            public delegate void GetColorTableSGI_(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, IntPtr table);
+            public delegate void GetColorTableParameterfvSGI_(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters);
+            public delegate void GetColorTableParameterivSGI_(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters);
+            public delegate void PixelTexGenSGIX(GLenum mode);
+            public delegate void PixelTexGenParameteriSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint param);
+            public delegate void PixelTexGenParameterivSGIS_(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters);
+            public delegate void PixelTexGenParameterfSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat param);
+            public delegate void PixelTexGenParameterfvSGIS_(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters);
+            public delegate void GetPixelTexGenParameterivSGIS_(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters);
+            public delegate void GetPixelTexGenParameterfvSGIS_(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters);
+            public delegate void TexImage4DSGIS_(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
+            public delegate void TexSubImage4DSGIS_(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels);
+            public delegate GLboolean AreTexturesResidentEXT_(GLsizei n, IntPtr textures, IntPtr residences);
+            public delegate void BindTextureEXT(Enums.TextureTarget target, GLuint texture);
+            public delegate void DeleteTexturesEXT_(GLsizei n, IntPtr textures);
+            public delegate void GenTexturesEXT_(GLsizei n, IntPtr textures);
+            public delegate GLboolean IsTextureEXT(GLuint texture);
+            public delegate void PrioritizeTexturesEXT_(GLsizei n, IntPtr textures, IntPtr priorities);
+            public delegate void DetailTexFuncSGIS_(Enums.TextureTarget target, GLsizei n, IntPtr points);
+            public delegate void GetDetailTexFuncSGIS_(Enums.TextureTarget target, IntPtr points);
+            public delegate void SharpenTexFuncSGIS_(Enums.TextureTarget target, GLsizei n, IntPtr points);
+            public delegate void GetSharpenTexFuncSGIS_(Enums.TextureTarget target, IntPtr points);
+            public delegate void SampleMaskSGIS(GLclampf value, Enums.Boolean invert);
+            public delegate void SamplePatternSGIS(Enums.SamplePatternSGIS pattern);
+            public delegate void ArrayElementEXT(GLint i);
+            public delegate void ColorPointerEXT_(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
+            public delegate void DrawArraysEXT(Enums.BeginMode mode, GLint first, GLsizei count);
+            public delegate void EdgeFlagPointerEXT_(GLsizei stride, GLsizei count, IntPtr pointer);
+            public delegate void GetPointervEXT_(Enums.GetPointervPName pname, IntPtr parameters);
+            public delegate void IndexPointerEXT_(Enums.IndexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
+            public delegate void NormalPointerEXT_(Enums.NormalPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
+            public delegate void TexCoordPointerEXT_(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
+            public delegate void VertexPointerEXT_(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer);
+            public delegate void BlendEquationEXT(Enums.BlendEquationModeEXT mode);
+            public delegate void SpriteParameterfSGIX(GLenum pname, GLfloat param);
+            public delegate void SpriteParameterfvSGIX_(GLenum pname, IntPtr parameters);
+            public delegate void SpriteParameteriSGIX(GLenum pname, GLint param);
+            public delegate void SpriteParameterivSGIX_(GLenum pname, IntPtr parameters);
+            public delegate void PointParameterfEXT(GLenum pname, GLfloat param);
+            public delegate void PointParameterfvEXT_(GLenum pname, IntPtr parameters);
+            public delegate void PointParameterfSGIS(GLenum pname, GLfloat param);
+            public delegate void PointParameterfvSGIS_(GLenum pname, IntPtr parameters);
+            public delegate GLint GetInstrumentsSGIX();
+            public delegate void InstrumentsBufferSGIX_(GLsizei size, IntPtr buffer);
+            public delegate GLint PollInstrumentsSGIX_(IntPtr marker_p);
+            public delegate void ReadInstrumentsSGIX(GLint marker);
+            public delegate void StartInstrumentsSGIX();
+            public delegate void StopInstrumentsSGIX(GLint marker);
+            public delegate void FrameZoomSGIX(GLint factor);
+            public delegate void TagSampleBufferSGIX();
+            public delegate void DeformationMap3dSGIX_(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, IntPtr points);
+            public delegate void DeformationMap3fSGIX_(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, IntPtr points);
+            public delegate void DeformSGIX(Enums.FfdMaskSGIX mask);
+            public delegate void LoadIdentityDeformationMapSGIX(Enums.FfdMaskSGIX mask);
+            public delegate void ReferencePlaneSGIX_(IntPtr equation);
+            public delegate void FlushRasterSGIX();
+            public delegate void FogFuncSGIS_(GLsizei n, IntPtr points);
+            public delegate void GetFogFuncSGIS_(IntPtr points);
+            public delegate void ImageTransformParameteriHP(GLenum target, GLenum pname, GLint param);
+            public delegate void ImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param);
+            public delegate void ImageTransformParameterivHP_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void ImageTransformParameterfvHP_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetImageTransformParameterivHP_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetImageTransformParameterfvHP_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void ColorSubTableEXT_(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data);
+            public delegate void CopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
+            public delegate void HintPGI(GLenum target, GLint mode);
+            public delegate void ColorTableEXT_(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table);
+            public delegate void GetColorTableEXT_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, IntPtr data);
+            public delegate void GetColorTableParameterivEXT_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetColorTableParameterfvEXT_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetListParameterfvSGIX_(GLuint list, Enums.ListParameterName pname, IntPtr parameters);
+            public delegate void GetListParameterivSGIX_(GLuint list, Enums.ListParameterName pname, IntPtr parameters);
+            public delegate void ListParameterfSGIX(GLuint list, Enums.ListParameterName pname, GLfloat param);
+            public delegate void ListParameterfvSGIX_(GLuint list, Enums.ListParameterName pname, IntPtr parameters);
+            public delegate void ListParameteriSGIX(GLuint list, Enums.ListParameterName pname, GLint param);
+            public delegate void ListParameterivSGIX_(GLuint list, Enums.ListParameterName pname, IntPtr parameters);
+            public delegate void IndexMaterialEXT(Enums.MaterialFace face, GLenum mode);
+            public delegate void IndexFuncEXT(GLenum func, GLclampf reference);
+            public delegate void LockArraysEXT(GLint first, GLsizei count);
+            public delegate void UnlockArraysEXT();
+            public delegate void CullParameterdvEXT_(GLenum pname, IntPtr parameters);
+            public delegate void CullParameterfvEXT_(GLenum pname, IntPtr parameters);
+            public delegate void FragmentColorMaterialSGIX(Enums.MaterialFace face, Enums.MaterialParameter mode);
+            public delegate void FragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param);
+            public delegate void FragmentLightfvSGIX_(GLenum light, GLenum pname, IntPtr parameters);
+            public delegate void FragmentLightiSGIX(GLenum light, GLenum pname, GLint param);
+            public delegate void FragmentLightivSGIX_(GLenum light, GLenum pname, IntPtr parameters);
+            public delegate void FragmentLightModelfSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat param);
+            public delegate void FragmentLightModelfvSGIX_(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters);
+            public delegate void FragmentLightModeliSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint param);
+            public delegate void FragmentLightModelivSGIX_(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters);
+            public delegate void FragmentMaterialfSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param);
+            public delegate void FragmentMaterialfvSGIX_(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters);
+            public delegate void FragmentMaterialiSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param);
+            public delegate void FragmentMaterialivSGIX_(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters);
+            public delegate void GetFragmentLightfvSGIX_(GLenum light, GLenum pname, IntPtr parameters);
+            public delegate void GetFragmentLightivSGIX_(GLenum light, GLenum pname, IntPtr parameters);
+            public delegate void GetFragmentMaterialfvSGIX_(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters);
+            public delegate void GetFragmentMaterialivSGIX_(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters);
+            public delegate void LightEnviSGIX(Enums.LightEnvParameterSGIX pname, GLint param);
+            public delegate void DrawRangeElementsEXT_(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices);
+            public delegate void ApplyTextureEXT(GLenum mode);
+            public delegate void TextureLightEXT(GLenum pname);
+            public delegate void TextureMaterialEXT(Enums.MaterialFace face, Enums.MaterialParameter mode);
+            public delegate void AsyncMarkerSGIX(GLuint marker);
+            public delegate GLint FinishAsyncSGIX_(IntPtr markerp);
+            public delegate GLint PollAsyncSGIX_(IntPtr markerp);
+            public delegate GLuint GenAsyncMarkersSGIX(GLsizei range);
+            public delegate void DeleteAsyncMarkersSGIX(GLuint marker, GLsizei range);
+            public delegate GLboolean IsAsyncMarkerSGIX(GLuint marker);
+            public delegate void VertexPointervINTEL_(GLint size, Enums.VertexPointerType type, IntPtr pointer);
+            public delegate void NormalPointervINTEL_(Enums.NormalPointerType type, IntPtr pointer);
+            public delegate void ColorPointervINTEL_(GLint size, Enums.VertexPointerType type, IntPtr pointer);
+            public delegate void TexCoordPointervINTEL_(GLint size, Enums.VertexPointerType type, IntPtr pointer);
+            public delegate void PixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param);
+            public delegate void PixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param);
+            public delegate void PixelTransformParameterivEXT_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void PixelTransformParameterfvEXT_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void SecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue);
+            public delegate void SecondaryColor3bvEXT_(IntPtr v);
+            public delegate void SecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue);
+            public delegate void SecondaryColor3dvEXT_(IntPtr v);
+            public delegate void SecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue);
+            public delegate void SecondaryColor3fvEXT_(IntPtr v);
+            public delegate void SecondaryColor3iEXT(GLint red, GLint green, GLint blue);
+            public delegate void SecondaryColor3ivEXT_(IntPtr v);
+            public delegate void SecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue);
+            public delegate void SecondaryColor3svEXT_(IntPtr v);
+            public delegate void SecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue);
+            public delegate void SecondaryColor3ubvEXT_(IntPtr v);
+            public delegate void SecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue);
+            public delegate void SecondaryColor3uivEXT_(IntPtr v);
+            public delegate void SecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue);
+            public delegate void SecondaryColor3usvEXT_(IntPtr v);
+            public delegate void SecondaryColorPointerEXT_(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer);
+            public delegate void TextureNormalEXT(GLenum mode);
+            public delegate void MultiDrawArraysEXT_(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount);
+            public delegate void MultiDrawElementsEXT_(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount);
+            public delegate void FogCoordfEXT(GLfloat coord);
+            public delegate void FogCoordfvEXT_(IntPtr coord);
+            public delegate void FogCoorddEXT(GLdouble coord);
+            public delegate void FogCoorddvEXT_(IntPtr coord);
+            public delegate void FogCoordPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer);
+            public delegate void Tangent3bEXT(GLbyte tx, GLbyte ty, GLbyte tz);
+            public delegate void Tangent3bvEXT_(IntPtr v);
+            public delegate void Tangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz);
+            public delegate void Tangent3dvEXT_(IntPtr v);
+            public delegate void Tangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz);
+            public delegate void Tangent3fvEXT_(IntPtr v);
+            public delegate void Tangent3iEXT(GLint tx, GLint ty, GLint tz);
+            public delegate void Tangent3ivEXT_(IntPtr v);
+            public delegate void Tangent3sEXT(GLshort tx, GLshort ty, GLshort tz);
+            public delegate void Tangent3svEXT_(IntPtr v);
+            public delegate void Binormal3bEXT(GLbyte bx, GLbyte by, GLbyte bz);
+            public delegate void Binormal3bvEXT_(IntPtr v);
+            public delegate void Binormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz);
+            public delegate void Binormal3dvEXT_(IntPtr v);
+            public delegate void Binormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz);
+            public delegate void Binormal3fvEXT_(IntPtr v);
+            public delegate void Binormal3iEXT(GLint bx, GLint by, GLint bz);
+            public delegate void Binormal3ivEXT_(IntPtr v);
+            public delegate void Binormal3sEXT(GLshort bx, GLshort by, GLshort bz);
+            public delegate void Binormal3svEXT_(IntPtr v);
+            public delegate void TangentPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer);
+            public delegate void BinormalPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer);
+            public delegate void FinishTextureSUNX();
+            public delegate void GlobalAlphaFactorbSUN(GLbyte factor);
+            public delegate void GlobalAlphaFactorsSUN(GLshort factor);
+            public delegate void GlobalAlphaFactoriSUN(GLint factor);
+            public delegate void GlobalAlphaFactorfSUN(GLfloat factor);
+            public delegate void GlobalAlphaFactordSUN(GLdouble factor);
+            public delegate void GlobalAlphaFactorubSUN(GLubyte factor);
+            public delegate void GlobalAlphaFactorusSUN(GLushort factor);
+            public delegate void GlobalAlphaFactoruiSUN(GLuint factor);
+            public delegate void ReplacementCodeuiSUN(GLuint code);
+            public delegate void ReplacementCodeusSUN(GLushort code);
+            public delegate void ReplacementCodeubSUN(GLubyte code);
+            public delegate void ReplacementCodeuivSUN_(IntPtr code);
+            public delegate void ReplacementCodeusvSUN_(IntPtr code);
+            public delegate void ReplacementCodeubvSUN_(IntPtr code);
+            public delegate void ReplacementCodePointerSUN_(GLenum type, GLsizei stride, IntPtr pointer);
+            public delegate void Color4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
+            public delegate void Color4ubVertex2fvSUN_(IntPtr c, IntPtr v);
+            public delegate void Color4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void Color4ubVertex3fvSUN_(IntPtr c, IntPtr v);
+            public delegate void Color3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void Color3fVertex3fvSUN_(IntPtr c, IntPtr v);
+            public delegate void Normal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void Normal3fVertex3fvSUN_(IntPtr n, IntPtr v);
+            public delegate void Color4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void Color4fNormal3fVertex3fvSUN_(IntPtr c, IntPtr n, IntPtr v);
+            public delegate void TexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void TexCoord2fVertex3fvSUN_(IntPtr tc, IntPtr v);
+            public delegate void TexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void TexCoord4fVertex4fvSUN_(IntPtr tc, IntPtr v);
+            public delegate void TexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void TexCoord2fColor4ubVertex3fvSUN_(IntPtr tc, IntPtr c, IntPtr v);
+            public delegate void TexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void TexCoord2fColor3fVertex3fvSUN_(IntPtr tc, IntPtr c, IntPtr v);
+            public delegate void TexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void TexCoord2fNormal3fVertex3fvSUN_(IntPtr tc, IntPtr n, IntPtr v);
+            public delegate void TexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void TexCoord2fColor4fNormal3fVertex3fvSUN_(IntPtr tc, IntPtr c, IntPtr n, IntPtr v);
+            public delegate void TexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void TexCoord4fColor4fNormal3fVertex4fvSUN_(IntPtr tc, IntPtr c, IntPtr n, IntPtr v);
+            public delegate void ReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void ReplacementCodeuiVertex3fvSUN_(IntPtr rc, IntPtr v);
+            public delegate void ReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void ReplacementCodeuiColor4ubVertex3fvSUN_(IntPtr rc, IntPtr c, IntPtr v);
+            public delegate void ReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void ReplacementCodeuiColor3fVertex3fvSUN_(IntPtr rc, IntPtr c, IntPtr v);
+            public delegate void ReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void ReplacementCodeuiNormal3fVertex3fvSUN_(IntPtr rc, IntPtr n, IntPtr v);
+            public delegate void ReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(IntPtr rc, IntPtr c, IntPtr n, IntPtr v);
+            public delegate void ReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void ReplacementCodeuiTexCoord2fVertex3fvSUN_(IntPtr rc, IntPtr tc, IntPtr v);
+            public delegate void ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(IntPtr rc, IntPtr tc, IntPtr n, IntPtr v);
+            public delegate void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v);
+            public delegate void BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+            public delegate void BlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+            public delegate void VertexWeightfEXT(GLfloat weight);
+            public delegate void VertexWeightfvEXT_(IntPtr weight);
+            public delegate void VertexWeightPointerEXT_(GLsizei size, GLenum type, GLsizei stride, IntPtr pointer);
+            public delegate void FlushVertexArrayRangeNV();
+            public delegate void VertexArrayRangeNV_(GLsizei length, IntPtr pointer);
+            public delegate void CombinerParameterfvNV_(GLenum pname, IntPtr parameters);
+            public delegate void CombinerParameterfNV(GLenum pname, GLfloat param);
+            public delegate void CombinerParameterivNV_(GLenum pname, IntPtr parameters);
+            public delegate void CombinerParameteriNV(GLenum pname, GLint param);
+            public delegate void CombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+            public delegate void CombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, Enums.Boolean abDotProduct, Enums.Boolean cdDotProduct, Enums.Boolean muxSum);
+            public delegate void FinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
+            public delegate void GetCombinerInputParameterfvNV_(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters);
+            public delegate void GetCombinerInputParameterivNV_(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters);
+            public delegate void GetCombinerOutputParameterfvNV_(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters);
+            public delegate void GetCombinerOutputParameterivNV_(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters);
+            public delegate void GetFinalCombinerInputParameterfvNV_(GLenum variable, GLenum pname, IntPtr parameters);
+            public delegate void GetFinalCombinerInputParameterivNV_(GLenum variable, GLenum pname, IntPtr parameters);
+            public delegate void ResizeBuffersMESA();
+            public delegate void WindowPos2dMESA(GLdouble x, GLdouble y);
+            public delegate void WindowPos2dvMESA_(IntPtr v);
+            public delegate void WindowPos2fMESA(GLfloat x, GLfloat y);
+            public delegate void WindowPos2fvMESA_(IntPtr v);
+            public delegate void WindowPos2iMESA(GLint x, GLint y);
+            public delegate void WindowPos2ivMESA_(IntPtr v);
+            public delegate void WindowPos2sMESA(GLshort x, GLshort y);
+            public delegate void WindowPos2svMESA_(IntPtr v);
+            public delegate void WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z);
+            public delegate void WindowPos3dvMESA_(IntPtr v);
+            public delegate void WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z);
+            public delegate void WindowPos3fvMESA_(IntPtr v);
+            public delegate void WindowPos3iMESA(GLint x, GLint y, GLint z);
+            public delegate void WindowPos3ivMESA_(IntPtr v);
+            public delegate void WindowPos3sMESA(GLshort x, GLshort y, GLshort z);
+            public delegate void WindowPos3svMESA_(IntPtr v);
+            public delegate void WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+            public delegate void WindowPos4dvMESA_(IntPtr v);
+            public delegate void WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void WindowPos4fvMESA_(IntPtr v);
+            public delegate void WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w);
+            public delegate void WindowPos4ivMESA_(IntPtr v);
+            public delegate void WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w);
+            public delegate void WindowPos4svMESA_(IntPtr v);
+            public delegate void MultiModeDrawArraysIBM_(IntPtr mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride);
+            public delegate void MultiModeDrawElementsIBM_(IntPtr mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride);
+            public delegate void ColorPointerListIBM_(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
+            public delegate void SecondaryColorPointerListIBM_(GLint size, GLenum type, GLint stride, IntPtr pointer, GLint ptrstride);
+            public delegate void EdgeFlagPointerListIBM_(GLint stride, IntPtr pointer, GLint ptrstride);
+            public delegate void FogCoordPointerListIBM_(GLenum type, GLint stride, IntPtr pointer, GLint ptrstride);
+            public delegate void IndexPointerListIBM_(Enums.IndexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
+            public delegate void NormalPointerListIBM_(Enums.NormalPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
+            public delegate void TexCoordPointerListIBM_(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
+            public delegate void VertexPointerListIBM_(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride);
+            public delegate void TbufferMask3DFX(GLuint mask);
+            public delegate void SampleMaskEXT(GLclampf value, Enums.Boolean invert);
+            public delegate void SamplePatternEXT(GLenum pattern);
+            public delegate void TextureColorMaskSGIS(Enums.Boolean red, Enums.Boolean green, Enums.Boolean blue, Enums.Boolean alpha);
+            public delegate void IglooInterfaceSGIX_(GLenum pname, IntPtr parameters);
+            public delegate void DeleteFencesNV_(GLsizei n, IntPtr fences);
+            public delegate void GenFencesNV_(GLsizei n, IntPtr fences);
+            public delegate GLboolean IsFenceNV(GLuint fence);
+            public delegate GLboolean TestFenceNV(GLuint fence);
+            public delegate void GetFenceivNV_(GLuint fence, GLenum pname, IntPtr parameters);
+            public delegate void FinishFenceNV(GLuint fence);
+            public delegate void SetFenceNV(GLuint fence, GLenum condition);
+            public delegate void MapControlPointsNV_(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, Enums.Boolean packed, IntPtr points);
+            public delegate void MapParameterivNV_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void MapParameterfvNV_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetMapControlPointsNV_(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, Enums.Boolean packed, IntPtr points);
+            public delegate void GetMapParameterivNV_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetMapParameterfvNV_(GLenum target, GLenum pname, IntPtr parameters);
+            public delegate void GetMapAttribParameterivNV_(GLenum target, GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetMapAttribParameterfvNV_(GLenum target, GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void EvalMapsNV(GLenum target, GLenum mode);
+            public delegate void CombinerStageParameterfvNV_(GLenum stage, GLenum pname, IntPtr parameters);
+            public delegate void GetCombinerStageParameterfvNV_(GLenum stage, GLenum pname, IntPtr parameters);
+            public delegate GLboolean AreProgramsResidentNV_(GLsizei n, IntPtr programs, IntPtr residences);
+            public delegate void BindProgramNV(GLenum target, GLuint id);
+            public delegate void DeleteProgramsNV_(GLsizei n, IntPtr programs);
+            public delegate void ExecuteProgramNV_(GLenum target, GLuint id, IntPtr parameters);
+            public delegate void GenProgramsNV_(GLsizei n, IntPtr programs);
+            public delegate void GetProgramParameterdvNV_(GLenum target, GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetProgramParameterfvNV_(GLenum target, GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetProgramivNV_(GLuint id, GLenum pname, IntPtr parameters);
+            public delegate void GetProgramStringNV_(GLuint id, GLenum pname, IntPtr program);
+            public delegate void GetTrackMatrixivNV_(GLenum target, GLuint address, GLenum pname, IntPtr parameters);
+            public delegate void GetVertexAttribdvNV_(GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetVertexAttribfvNV_(GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetVertexAttribivNV_(GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetVertexAttribPointervNV_(GLuint index, GLenum pname, IntPtr pointer);
+            public delegate GLboolean IsProgramNV(GLuint id);
+            public delegate void LoadProgramNV_(GLenum target, GLuint id, GLsizei len, IntPtr program);
+            public delegate void ProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+            public delegate void ProgramParameter4dvNV_(GLenum target, GLuint index, IntPtr v);
+            public delegate void ProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void ProgramParameter4fvNV_(GLenum target, GLuint index, IntPtr v);
+            public delegate void ProgramParameters4dvNV_(GLenum target, GLuint index, GLuint count, IntPtr v);
+            public delegate void ProgramParameters4fvNV_(GLenum target, GLuint index, GLuint count, IntPtr v);
+            public delegate void RequestResidentProgramsNV_(GLsizei n, IntPtr programs);
+            public delegate void TrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform);
+            public delegate void VertexAttribPointerNV_(GLuint index, GLint fsize, GLenum type, GLsizei stride, IntPtr pointer);
+            public delegate void VertexAttrib1dNV(GLuint index, GLdouble x);
+            public delegate void VertexAttrib1dvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib1fNV(GLuint index, GLfloat x);
+            public delegate void VertexAttrib1fvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib1sNV(GLuint index, GLshort x);
+            public delegate void VertexAttrib1svNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y);
+            public delegate void VertexAttrib2dvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y);
+            public delegate void VertexAttrib2fvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib2sNV(GLuint index, GLshort x, GLshort y);
+            public delegate void VertexAttrib2svNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+            public delegate void VertexAttrib3dvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void VertexAttrib3fvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z);
+            public delegate void VertexAttrib3svNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+            public delegate void VertexAttrib4dvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void VertexAttrib4fvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+            public delegate void VertexAttrib4svNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+            public delegate void VertexAttrib4ubvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttribs1dvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs1fvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs1svNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs2dvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs2fvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs2svNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs3dvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs3fvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs3svNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs4dvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs4fvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs4svNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void VertexAttribs4ubvNV_(GLuint index, GLsizei count, IntPtr v);
+            public delegate void TexBumpParameterivATI_(GLenum pname, IntPtr param);
+            public delegate void TexBumpParameterfvATI_(GLenum pname, IntPtr param);
+            public delegate void GetTexBumpParameterivATI_(GLenum pname, IntPtr param);
+            public delegate void GetTexBumpParameterfvATI_(GLenum pname, IntPtr param);
+            public delegate GLuint GenFragmentShadersATI(GLuint range);
+            public delegate void BindFragmentShaderATI(GLuint id);
+            public delegate void DeleteFragmentShaderATI(GLuint id);
+            public delegate void BeginFragmentShaderATI();
+            public delegate void EndFragmentShaderATI();
+            public delegate void PassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle);
+            public delegate void SampleMapATI(GLuint dst, GLuint interp, GLenum swizzle);
+            public delegate void ColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+            public delegate void ColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+            public delegate void ColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+            public delegate void AlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+            public delegate void AlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+            public delegate void AlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+            public delegate void SetFragmentShaderConstantATI_(GLuint dst, IntPtr value);
+            public delegate void PNTrianglesiATI(GLenum pname, GLint param);
+            public delegate void PNTrianglesfATI(GLenum pname, GLfloat param);
+            public delegate GLuint NewObjectBufferATI_(GLsizei size, IntPtr pointer, GLenum usage);
+            public delegate GLboolean IsObjectBufferATI(GLuint buffer);
+            public delegate void UpdateObjectBufferATI_(GLuint buffer, GLuint offset, GLsizei size, IntPtr pointer, GLenum preserve);
+            public delegate void GetObjectBufferfvATI_(GLuint buffer, GLenum pname, IntPtr parameters);
+            public delegate void GetObjectBufferivATI_(GLuint buffer, GLenum pname, IntPtr parameters);
+            public delegate void FreeObjectBufferATI(GLuint buffer);
+            public delegate void ArrayObjectATI(Enums.EnableCap array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+            public delegate void GetArrayObjectfvATI_(Enums.EnableCap array, GLenum pname, IntPtr parameters);
+            public delegate void GetArrayObjectivATI_(Enums.EnableCap array, GLenum pname, IntPtr parameters);
+            public delegate void VariantArrayObjectATI(GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset);
+            public delegate void GetVariantArrayObjectfvATI_(GLuint id, GLenum pname, IntPtr parameters);
+            public delegate void GetVariantArrayObjectivATI_(GLuint id, GLenum pname, IntPtr parameters);
+            public delegate void BeginVertexShaderEXT();
+            public delegate void EndVertexShaderEXT();
+            public delegate void BindVertexShaderEXT(GLuint id);
+            public delegate GLuint GenVertexShadersEXT(GLuint range);
+            public delegate void DeleteVertexShaderEXT(GLuint id);
+            public delegate void ShaderOp1EXT(GLenum op, GLuint res, GLuint arg1);
+            public delegate void ShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2);
+            public delegate void ShaderOp3EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
+            public delegate void SwizzleEXT(GLuint res, GLuint @in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+            public delegate void WriteMaskEXT(GLuint res, GLuint @in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW);
+            public delegate void InsertComponentEXT(GLuint res, GLuint src, GLuint num);
+            public delegate void ExtractComponentEXT(GLuint res, GLuint src, GLuint num);
+            public delegate GLuint GenSymbolsEXT(GLenum datatype, GLenum storagetype, GLenum range, GLuint components);
+            public delegate void SetInvariantEXT_(GLuint id, GLenum type, IntPtr addr);
+            public delegate void SetLocalConstantEXT_(GLuint id, GLenum type, IntPtr addr);
+            public delegate void VariantbvEXT_(GLuint id, IntPtr addr);
+            public delegate void VariantsvEXT_(GLuint id, IntPtr addr);
+            public delegate void VariantivEXT_(GLuint id, IntPtr addr);
+            public delegate void VariantfvEXT_(GLuint id, IntPtr addr);
+            public delegate void VariantdvEXT_(GLuint id, IntPtr addr);
+            public delegate void VariantubvEXT_(GLuint id, IntPtr addr);
+            public delegate void VariantusvEXT_(GLuint id, IntPtr addr);
+            public delegate void VariantuivEXT_(GLuint id, IntPtr addr);
+            public delegate void VariantPointerEXT_(GLuint id, GLenum type, GLuint stride, IntPtr addr);
+            public delegate void EnableVariantClientStateEXT(GLuint id);
+            public delegate void DisableVariantClientStateEXT(GLuint id);
+            public delegate GLuint BindLightParameterEXT(Enums.LightName light, Enums.LightParameter value);
+            public delegate GLuint BindMaterialParameterEXT(Enums.MaterialFace face, Enums.MaterialParameter value);
+            public delegate GLuint BindTexGenParameterEXT(GLenum unit, Enums.TextureCoordName coord, Enums.TextureGenParameter value);
+            public delegate GLuint BindTextureUnitParameterEXT(GLenum unit, GLenum value);
+            public delegate GLuint BindParameterEXT(GLenum value);
+            public delegate GLboolean IsVariantEnabledEXT(GLuint id, GLenum cap);
+            public delegate void GetVariantBooleanvEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetVariantIntegervEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetVariantFloatvEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetVariantPointervEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetInvariantBooleanvEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetInvariantIntegervEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetInvariantFloatvEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetLocalConstantBooleanvEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetLocalConstantIntegervEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void GetLocalConstantFloatvEXT_(GLuint id, GLenum value, IntPtr data);
+            public delegate void VertexStream1sATI(GLenum stream, GLshort x);
+            public delegate void VertexStream1svATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream1iATI(GLenum stream, GLint x);
+            public delegate void VertexStream1ivATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream1fATI(GLenum stream, GLfloat x);
+            public delegate void VertexStream1fvATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream1dATI(GLenum stream, GLdouble x);
+            public delegate void VertexStream1dvATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream2sATI(GLenum stream, GLshort x, GLshort y);
+            public delegate void VertexStream2svATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream2iATI(GLenum stream, GLint x, GLint y);
+            public delegate void VertexStream2ivATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream2fATI(GLenum stream, GLfloat x, GLfloat y);
+            public delegate void VertexStream2fvATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream2dATI(GLenum stream, GLdouble x, GLdouble y);
+            public delegate void VertexStream2dvATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream3sATI(GLenum stream, GLshort x, GLshort y, GLshort z);
+            public delegate void VertexStream3svATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z);
+            public delegate void VertexStream3ivATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z);
+            public delegate void VertexStream3fvATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z);
+            public delegate void VertexStream3dvATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream4sATI(GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w);
+            public delegate void VertexStream4svATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w);
+            public delegate void VertexStream4ivATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void VertexStream4fvATI_(GLenum stream, IntPtr coords);
+            public delegate void VertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+            public delegate void VertexStream4dvATI_(GLenum stream, IntPtr coords);
+            public delegate void NormalStream3bATI(GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz);
+            public delegate void NormalStream3bvATI_(GLenum stream, IntPtr coords);
+            public delegate void NormalStream3sATI(GLenum stream, GLshort nx, GLshort ny, GLshort nz);
+            public delegate void NormalStream3svATI_(GLenum stream, IntPtr coords);
+            public delegate void NormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz);
+            public delegate void NormalStream3ivATI_(GLenum stream, IntPtr coords);
+            public delegate void NormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz);
+            public delegate void NormalStream3fvATI_(GLenum stream, IntPtr coords);
+            public delegate void NormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz);
+            public delegate void NormalStream3dvATI_(GLenum stream, IntPtr coords);
+            public delegate void ClientActiveVertexStreamATI(GLenum stream);
+            public delegate void VertexBlendEnviATI(GLenum pname, GLint param);
+            public delegate void VertexBlendEnvfATI(GLenum pname, GLfloat param);
+            public delegate void ElementPointerATI_(GLenum type, IntPtr pointer);
+            public delegate void DrawElementArrayATI(Enums.BeginMode mode, GLsizei count);
+            public delegate void DrawRangeElementArrayATI(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count);
+            public delegate void DrawMeshArraysSUN(Enums.BeginMode mode, GLint first, GLsizei count, GLsizei width);
+            public delegate void GenOcclusionQueriesNV_(GLsizei n, IntPtr ids);
+            public delegate void DeleteOcclusionQueriesNV_(GLsizei n, IntPtr ids);
+            public delegate GLboolean IsOcclusionQueryNV(GLuint id);
+            public delegate void BeginOcclusionQueryNV(GLuint id);
+            public delegate void EndOcclusionQueryNV();
+            public delegate void GetOcclusionQueryivNV_(GLuint id, GLenum pname, IntPtr parameters);
+            public delegate void GetOcclusionQueryuivNV_(GLuint id, GLenum pname, IntPtr parameters);
+            public delegate void PointParameteriNV(GLenum pname, GLint param);
+            public delegate void PointParameterivNV_(GLenum pname, IntPtr parameters);
+            public delegate void ActiveStencilFaceEXT(GLenum face);
+            public delegate void ElementPointerAPPLE_(GLenum type, IntPtr pointer);
+            public delegate void DrawElementArrayAPPLE(Enums.BeginMode mode, GLint first, GLsizei count);
+            public delegate void DrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint first, GLsizei count);
+            public delegate void MultiDrawElementArrayAPPLE_(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount);
+            public delegate void MultiDrawRangeElementArrayAPPLE_(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, IntPtr count, GLsizei primcount);
+            public delegate void GenFencesAPPLE_(GLsizei n, IntPtr fences);
+            public delegate void DeleteFencesAPPLE_(GLsizei n, IntPtr fences);
+            public delegate void SetFenceAPPLE(GLuint fence);
+            public delegate GLboolean IsFenceAPPLE(GLuint fence);
+            public delegate GLboolean TestFenceAPPLE(GLuint fence);
+            public delegate void FinishFenceAPPLE(GLuint fence);
+            public delegate GLboolean TestObjectAPPLE(GLenum @object, GLuint name);
+            public delegate void FinishObjectAPPLE(GLenum @object, GLint name);
+            public delegate void BindVertexArrayAPPLE(GLuint array);
+            public delegate void DeleteVertexArraysAPPLE_(GLsizei n, IntPtr arrays);
+            public delegate void GenVertexArraysAPPLE_(GLsizei n, IntPtr arrays);
+            public delegate GLboolean IsVertexArrayAPPLE(GLuint array);
+            public delegate void VertexArrayRangeAPPLE_(GLsizei length, IntPtr pointer);
+            public delegate void FlushVertexArrayRangeAPPLE_(GLsizei length, IntPtr pointer);
+            public delegate void VertexArrayParameteriAPPLE(GLenum pname, GLint param);
+            public delegate void DrawBuffersATI_(GLsizei n, IntPtr bufs);
+            public delegate void ProgramNamedParameter4fNV_(GLuint id, GLsizei len, IntPtr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+            public delegate void ProgramNamedParameter4dNV_(GLuint id, GLsizei len, IntPtr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+            public delegate void ProgramNamedParameter4fvNV_(GLuint id, GLsizei len, IntPtr name, IntPtr v);
+            public delegate void ProgramNamedParameter4dvNV_(GLuint id, GLsizei len, IntPtr name, IntPtr v);
+            public delegate void GetProgramNamedParameterfvNV_(GLuint id, GLsizei len, IntPtr name, IntPtr parameters);
+            public delegate void GetProgramNamedParameterdvNV_(GLuint id, GLsizei len, IntPtr name, IntPtr parameters);
+            public delegate void Vertex2hNV(GLhalfNV x, GLhalfNV y);
+            public delegate void Vertex2hvNV_(IntPtr v);
+            public delegate void Vertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z);
+            public delegate void Vertex3hvNV_(IntPtr v);
+            public delegate void Vertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
+            public delegate void Vertex4hvNV_(IntPtr v);
+            public delegate void Normal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz);
+            public delegate void Normal3hvNV_(IntPtr v);
+            public delegate void Color3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue);
+            public delegate void Color3hvNV_(IntPtr v);
+            public delegate void Color4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha);
+            public delegate void Color4hvNV_(IntPtr v);
+            public delegate void TexCoord1hNV(GLhalfNV s);
+            public delegate void TexCoord1hvNV_(IntPtr v);
+            public delegate void TexCoord2hNV(GLhalfNV s, GLhalfNV t);
+            public delegate void TexCoord2hvNV_(IntPtr v);
+            public delegate void TexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r);
+            public delegate void TexCoord3hvNV_(IntPtr v);
+            public delegate void TexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
+            public delegate void TexCoord4hvNV_(IntPtr v);
+            public delegate void MultiTexCoord1hNV(GLenum target, GLhalfNV s);
+            public delegate void MultiTexCoord1hvNV_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord2hNV(GLenum target, GLhalfNV s, GLhalfNV t);
+            public delegate void MultiTexCoord2hvNV_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord3hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r);
+            public delegate void MultiTexCoord3hvNV_(GLenum target, IntPtr v);
+            public delegate void MultiTexCoord4hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
+            public delegate void MultiTexCoord4hvNV_(GLenum target, IntPtr v);
+            public delegate void FogCoordhNV(GLhalfNV fog);
+            public delegate void FogCoordhvNV_(IntPtr fog);
+            public delegate void SecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue);
+            public delegate void SecondaryColor3hvNV_(IntPtr v);
+            public delegate void VertexWeighthNV(GLhalfNV weight);
+            public delegate void VertexWeighthvNV_(IntPtr weight);
+            public delegate void VertexAttrib1hNV(GLuint index, GLhalfNV x);
+            public delegate void VertexAttrib1hvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y);
+            public delegate void VertexAttrib2hvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z);
+            public delegate void VertexAttrib3hvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
+            public delegate void VertexAttrib4hvNV_(GLuint index, IntPtr v);
+            public delegate void VertexAttribs1hvNV_(GLuint index, GLsizei n, IntPtr v);
+            public delegate void VertexAttribs2hvNV_(GLuint index, GLsizei n, IntPtr v);
+            public delegate void VertexAttribs3hvNV_(GLuint index, GLsizei n, IntPtr v);
+            public delegate void VertexAttribs4hvNV_(GLuint index, GLsizei n, IntPtr v);
+            public delegate void PixelDataRangeNV_(GLenum target, GLsizei length, IntPtr pointer);
+            public delegate void FlushPixelDataRangeNV(GLenum target);
+            public delegate void PrimitiveRestartNV();
+            public delegate void PrimitiveRestartIndexNV(GLuint index);
+            public delegate IntPtr MapObjectBufferATI(GLuint buffer);
+            public delegate void UnmapObjectBufferATI(GLuint buffer);
+            public delegate void StencilOpSeparateATI(GLenum face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass);
+            public delegate void StencilFuncSeparateATI(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint reference, GLuint mask);
+            public delegate void VertexAttribArrayObjectATI(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, GLuint buffer, GLuint offset);
+            public delegate void GetVertexAttribArrayObjectfvATI_(GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void GetVertexAttribArrayObjectivATI_(GLuint index, GLenum pname, IntPtr parameters);
+            public delegate void DepthBoundsEXT(GLclampd zmin, GLclampd zmax);
+            public delegate void BlendEquationSeparateEXT(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha);
+            public delegate GLboolean IsRenderbufferEXT(GLuint renderbuffer);
+            public delegate void BindRenderbufferEXT(Enums.EXT_framebuffer_object target, GLuint renderbuffer);
+            public delegate void DeleteRenderbuffersEXT_(GLsizei n, IntPtr renderbuffers);
+            public delegate void GenRenderbuffersEXT_(GLsizei n, IntPtr renderbuffers);
+            public delegate void RenderbufferStorageEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object internalformat, GLsizei width, GLsizei height);
+            public delegate void GetRenderbufferParameterivEXT_(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, IntPtr parameters);
+            public delegate GLboolean IsFramebufferEXT(GLuint framebuffer);
+            public delegate void BindFramebufferEXT(Enums.EXT_framebuffer_object target, GLuint framebuffer);
+            public delegate void DeleteFramebuffersEXT_(GLsizei n, IntPtr framebuffers);
+            public delegate void GenFramebuffersEXT_(GLsizei n, IntPtr framebuffers);
+            public delegate GLenum CheckFramebufferStatusEXT(Enums.EXT_framebuffer_object target);
+            public delegate void FramebufferTexture1DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level);
+            public delegate void FramebufferTexture2DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level);
+            public delegate void FramebufferTexture3DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object textarget, GLuint texture, GLint level, GLint zoffset);
+            public delegate void FramebufferRenderbufferEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object renderbuffertarget, GLuint renderbuffer);
+            public delegate void GetFramebufferAttachmentParameterivEXT_(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, IntPtr parameters);
+            public delegate void GenerateMipmapEXT(Enums.EXT_framebuffer_object target);
+            public delegate void StringMarkerGREMEDY_(GLsizei len, IntPtr @string);
+            public delegate void StencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag);
+            public delegate void BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, Enums.ClearBufferMask mask, Enums.EXT_framebuffer_blit filter);
+            public delegate void RenderbufferStorageMultisampleEXT(Enums.EXT_framebuffer_multisample target, GLsizei samples, Enums.EXT_framebuffer_multisample internalformat, GLsizei width, GLsizei height);
+            public delegate void GetQueryObjecti64vEXT_(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters);
+            public delegate void GetQueryObjectui64vEXT_(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters);
+            public delegate void ProgramEnvParameters4fvEXT_(GLenum target, GLuint index, GLsizei count, IntPtr parameters);
+            public delegate void ProgramLocalParameters4fvEXT_(GLenum target, GLuint index, GLsizei count, IntPtr parameters);
+        }
+        #endregion
+
+        #region Static Functions (and static initialisation)
+
+        public static Delegates.ActiveTextureARB ActiveTextureARB = new Delegates.ActiveTextureARB(Imports.ActiveTextureARB);
+        public static Delegates.ClientActiveTextureARB ClientActiveTextureARB = new Delegates.ClientActiveTextureARB(Imports.ClientActiveTextureARB);
+        public static Delegates.MultiTexCoord1dARB MultiTexCoord1dARB = new Delegates.MultiTexCoord1dARB(Imports.MultiTexCoord1dARB);
+        public static Delegates.MultiTexCoord1dvARB_ MultiTexCoord1dvARB_ = new Delegates.MultiTexCoord1dvARB_(Imports.MultiTexCoord1dvARB_);
+        public static Delegates.MultiTexCoord1fARB MultiTexCoord1fARB = new Delegates.MultiTexCoord1fARB(Imports.MultiTexCoord1fARB);
+        public static Delegates.MultiTexCoord1fvARB_ MultiTexCoord1fvARB_ = new Delegates.MultiTexCoord1fvARB_(Imports.MultiTexCoord1fvARB_);
+        public static Delegates.MultiTexCoord1iARB MultiTexCoord1iARB = new Delegates.MultiTexCoord1iARB(Imports.MultiTexCoord1iARB);
+        public static Delegates.MultiTexCoord1ivARB_ MultiTexCoord1ivARB_ = new Delegates.MultiTexCoord1ivARB_(Imports.MultiTexCoord1ivARB_);
+        public static Delegates.MultiTexCoord1sARB MultiTexCoord1sARB = new Delegates.MultiTexCoord1sARB(Imports.MultiTexCoord1sARB);
+        public static Delegates.MultiTexCoord1svARB_ MultiTexCoord1svARB_ = new Delegates.MultiTexCoord1svARB_(Imports.MultiTexCoord1svARB_);
+        public static Delegates.MultiTexCoord2dARB MultiTexCoord2dARB = new Delegates.MultiTexCoord2dARB(Imports.MultiTexCoord2dARB);
+        public static Delegates.MultiTexCoord2dvARB_ MultiTexCoord2dvARB_ = new Delegates.MultiTexCoord2dvARB_(Imports.MultiTexCoord2dvARB_);
+        public static Delegates.MultiTexCoord2fARB MultiTexCoord2fARB = new Delegates.MultiTexCoord2fARB(Imports.MultiTexCoord2fARB);
+        public static Delegates.MultiTexCoord2fvARB_ MultiTexCoord2fvARB_ = new Delegates.MultiTexCoord2fvARB_(Imports.MultiTexCoord2fvARB_);
+        public static Delegates.MultiTexCoord2iARB MultiTexCoord2iARB = new Delegates.MultiTexCoord2iARB(Imports.MultiTexCoord2iARB);
+        public static Delegates.MultiTexCoord2ivARB_ MultiTexCoord2ivARB_ = new Delegates.MultiTexCoord2ivARB_(Imports.MultiTexCoord2ivARB_);
+        public static Delegates.MultiTexCoord2sARB MultiTexCoord2sARB = new Delegates.MultiTexCoord2sARB(Imports.MultiTexCoord2sARB);
+        public static Delegates.MultiTexCoord2svARB_ MultiTexCoord2svARB_ = new Delegates.MultiTexCoord2svARB_(Imports.MultiTexCoord2svARB_);
+        public static Delegates.MultiTexCoord3dARB MultiTexCoord3dARB = new Delegates.MultiTexCoord3dARB(Imports.MultiTexCoord3dARB);
+        public static Delegates.MultiTexCoord3dvARB_ MultiTexCoord3dvARB_ = new Delegates.MultiTexCoord3dvARB_(Imports.MultiTexCoord3dvARB_);
+        public static Delegates.MultiTexCoord3fARB MultiTexCoord3fARB = new Delegates.MultiTexCoord3fARB(Imports.MultiTexCoord3fARB);
+        public static Delegates.MultiTexCoord3fvARB_ MultiTexCoord3fvARB_ = new Delegates.MultiTexCoord3fvARB_(Imports.MultiTexCoord3fvARB_);
+        public static Delegates.MultiTexCoord3iARB MultiTexCoord3iARB = new Delegates.MultiTexCoord3iARB(Imports.MultiTexCoord3iARB);
+        public static Delegates.MultiTexCoord3ivARB_ MultiTexCoord3ivARB_ = new Delegates.MultiTexCoord3ivARB_(Imports.MultiTexCoord3ivARB_);
+        public static Delegates.MultiTexCoord3sARB MultiTexCoord3sARB = new Delegates.MultiTexCoord3sARB(Imports.MultiTexCoord3sARB);
+        public static Delegates.MultiTexCoord3svARB_ MultiTexCoord3svARB_ = new Delegates.MultiTexCoord3svARB_(Imports.MultiTexCoord3svARB_);
+        public static Delegates.MultiTexCoord4dARB MultiTexCoord4dARB = new Delegates.MultiTexCoord4dARB(Imports.MultiTexCoord4dARB);
+        public static Delegates.MultiTexCoord4dvARB_ MultiTexCoord4dvARB_ = new Delegates.MultiTexCoord4dvARB_(Imports.MultiTexCoord4dvARB_);
+        public static Delegates.MultiTexCoord4fARB MultiTexCoord4fARB = new Delegates.MultiTexCoord4fARB(Imports.MultiTexCoord4fARB);
+        public static Delegates.MultiTexCoord4fvARB_ MultiTexCoord4fvARB_ = new Delegates.MultiTexCoord4fvARB_(Imports.MultiTexCoord4fvARB_);
+        public static Delegates.MultiTexCoord4iARB MultiTexCoord4iARB = new Delegates.MultiTexCoord4iARB(Imports.MultiTexCoord4iARB);
+        public static Delegates.MultiTexCoord4ivARB_ MultiTexCoord4ivARB_ = new Delegates.MultiTexCoord4ivARB_(Imports.MultiTexCoord4ivARB_);
+        public static Delegates.MultiTexCoord4sARB MultiTexCoord4sARB = new Delegates.MultiTexCoord4sARB(Imports.MultiTexCoord4sARB);
+        public static Delegates.MultiTexCoord4svARB_ MultiTexCoord4svARB_ = new Delegates.MultiTexCoord4svARB_(Imports.MultiTexCoord4svARB_);
+        public static Delegates.LoadTransposeMatrixfARB_ LoadTransposeMatrixfARB_ = new Delegates.LoadTransposeMatrixfARB_(Imports.LoadTransposeMatrixfARB_);
+        public static Delegates.LoadTransposeMatrixdARB_ LoadTransposeMatrixdARB_ = new Delegates.LoadTransposeMatrixdARB_(Imports.LoadTransposeMatrixdARB_);
+        public static Delegates.MultTransposeMatrixfARB_ MultTransposeMatrixfARB_ = new Delegates.MultTransposeMatrixfARB_(Imports.MultTransposeMatrixfARB_);
+        public static Delegates.MultTransposeMatrixdARB_ MultTransposeMatrixdARB_ = new Delegates.MultTransposeMatrixdARB_(Imports.MultTransposeMatrixdARB_);
+        public static Delegates.SampleCoverageARB SampleCoverageARB = new Delegates.SampleCoverageARB(Imports.SampleCoverageARB);
+        public static Delegates.CompressedTexImage3DARB_ CompressedTexImage3DARB_ = new Delegates.CompressedTexImage3DARB_(Imports.CompressedTexImage3DARB_);
+        public static Delegates.CompressedTexImage2DARB_ CompressedTexImage2DARB_ = new Delegates.CompressedTexImage2DARB_(Imports.CompressedTexImage2DARB_);
+        public static Delegates.CompressedTexImage1DARB_ CompressedTexImage1DARB_ = new Delegates.CompressedTexImage1DARB_(Imports.CompressedTexImage1DARB_);
+        public static Delegates.CompressedTexSubImage3DARB_ CompressedTexSubImage3DARB_ = new Delegates.CompressedTexSubImage3DARB_(Imports.CompressedTexSubImage3DARB_);
+        public static Delegates.CompressedTexSubImage2DARB_ CompressedTexSubImage2DARB_ = new Delegates.CompressedTexSubImage2DARB_(Imports.CompressedTexSubImage2DARB_);
+        public static Delegates.CompressedTexSubImage1DARB_ CompressedTexSubImage1DARB_ = new Delegates.CompressedTexSubImage1DARB_(Imports.CompressedTexSubImage1DARB_);
+        public static Delegates.GetCompressedTexImageARB_ GetCompressedTexImageARB_ = new Delegates.GetCompressedTexImageARB_(Imports.GetCompressedTexImageARB_);
+        public static Delegates.PointParameterfARB PointParameterfARB = new Delegates.PointParameterfARB(Imports.PointParameterfARB);
+        public static Delegates.PointParameterfvARB_ PointParameterfvARB_ = new Delegates.PointParameterfvARB_(Imports.PointParameterfvARB_);
+        public static Delegates.WeightbvARB_ WeightbvARB_ = new Delegates.WeightbvARB_(Imports.WeightbvARB_);
+        public static Delegates.WeightsvARB_ WeightsvARB_ = new Delegates.WeightsvARB_(Imports.WeightsvARB_);
+        public static Delegates.WeightivARB_ WeightivARB_ = new Delegates.WeightivARB_(Imports.WeightivARB_);
+        public static Delegates.WeightfvARB_ WeightfvARB_ = new Delegates.WeightfvARB_(Imports.WeightfvARB_);
+        public static Delegates.WeightdvARB_ WeightdvARB_ = new Delegates.WeightdvARB_(Imports.WeightdvARB_);
+        public static Delegates.WeightubvARB_ WeightubvARB_ = new Delegates.WeightubvARB_(Imports.WeightubvARB_);
+        public static Delegates.WeightusvARB_ WeightusvARB_ = new Delegates.WeightusvARB_(Imports.WeightusvARB_);
+        public static Delegates.WeightuivARB_ WeightuivARB_ = new Delegates.WeightuivARB_(Imports.WeightuivARB_);
+        public static Delegates.WeightPointerARB_ WeightPointerARB_ = new Delegates.WeightPointerARB_(Imports.WeightPointerARB_);
+        public static Delegates.VertexBlendARB VertexBlendARB = new Delegates.VertexBlendARB(Imports.VertexBlendARB);
+        public static Delegates.CurrentPaletteMatrixARB CurrentPaletteMatrixARB = new Delegates.CurrentPaletteMatrixARB(Imports.CurrentPaletteMatrixARB);
+        public static Delegates.MatrixIndexubvARB_ MatrixIndexubvARB_ = new Delegates.MatrixIndexubvARB_(Imports.MatrixIndexubvARB_);
+        public static Delegates.MatrixIndexusvARB_ MatrixIndexusvARB_ = new Delegates.MatrixIndexusvARB_(Imports.MatrixIndexusvARB_);
+        public static Delegates.MatrixIndexuivARB_ MatrixIndexuivARB_ = new Delegates.MatrixIndexuivARB_(Imports.MatrixIndexuivARB_);
+        public static Delegates.MatrixIndexPointerARB_ MatrixIndexPointerARB_ = new Delegates.MatrixIndexPointerARB_(Imports.MatrixIndexPointerARB_);
+        public static Delegates.WindowPos2dARB WindowPos2dARB = new Delegates.WindowPos2dARB(Imports.WindowPos2dARB);
+        public static Delegates.WindowPos2dvARB_ WindowPos2dvARB_ = new Delegates.WindowPos2dvARB_(Imports.WindowPos2dvARB_);
+        public static Delegates.WindowPos2fARB WindowPos2fARB = new Delegates.WindowPos2fARB(Imports.WindowPos2fARB);
+        public static Delegates.WindowPos2fvARB_ WindowPos2fvARB_ = new Delegates.WindowPos2fvARB_(Imports.WindowPos2fvARB_);
+        public static Delegates.WindowPos2iARB WindowPos2iARB = new Delegates.WindowPos2iARB(Imports.WindowPos2iARB);
+        public static Delegates.WindowPos2ivARB_ WindowPos2ivARB_ = new Delegates.WindowPos2ivARB_(Imports.WindowPos2ivARB_);
+        public static Delegates.WindowPos2sARB WindowPos2sARB = new Delegates.WindowPos2sARB(Imports.WindowPos2sARB);
+        public static Delegates.WindowPos2svARB_ WindowPos2svARB_ = new Delegates.WindowPos2svARB_(Imports.WindowPos2svARB_);
+        public static Delegates.WindowPos3dARB WindowPos3dARB = new Delegates.WindowPos3dARB(Imports.WindowPos3dARB);
+        public static Delegates.WindowPos3dvARB_ WindowPos3dvARB_ = new Delegates.WindowPos3dvARB_(Imports.WindowPos3dvARB_);
+        public static Delegates.WindowPos3fARB WindowPos3fARB = new Delegates.WindowPos3fARB(Imports.WindowPos3fARB);
+        public static Delegates.WindowPos3fvARB_ WindowPos3fvARB_ = new Delegates.WindowPos3fvARB_(Imports.WindowPos3fvARB_);
+        public static Delegates.WindowPos3iARB WindowPos3iARB = new Delegates.WindowPos3iARB(Imports.WindowPos3iARB);
+        public static Delegates.WindowPos3ivARB_ WindowPos3ivARB_ = new Delegates.WindowPos3ivARB_(Imports.WindowPos3ivARB_);
+        public static Delegates.WindowPos3sARB WindowPos3sARB = new Delegates.WindowPos3sARB(Imports.WindowPos3sARB);
+        public static Delegates.WindowPos3svARB_ WindowPos3svARB_ = new Delegates.WindowPos3svARB_(Imports.WindowPos3svARB_);
+        public static Delegates.VertexAttrib1dARB VertexAttrib1dARB = new Delegates.VertexAttrib1dARB(Imports.VertexAttrib1dARB);
+        public static Delegates.VertexAttrib1dvARB_ VertexAttrib1dvARB_ = new Delegates.VertexAttrib1dvARB_(Imports.VertexAttrib1dvARB_);
+        public static Delegates.VertexAttrib1fARB VertexAttrib1fARB = new Delegates.VertexAttrib1fARB(Imports.VertexAttrib1fARB);
+        public static Delegates.VertexAttrib1fvARB_ VertexAttrib1fvARB_ = new Delegates.VertexAttrib1fvARB_(Imports.VertexAttrib1fvARB_);
+        public static Delegates.VertexAttrib1sARB VertexAttrib1sARB = new Delegates.VertexAttrib1sARB(Imports.VertexAttrib1sARB);
+        public static Delegates.VertexAttrib1svARB_ VertexAttrib1svARB_ = new Delegates.VertexAttrib1svARB_(Imports.VertexAttrib1svARB_);
+        public static Delegates.VertexAttrib2dARB VertexAttrib2dARB = new Delegates.VertexAttrib2dARB(Imports.VertexAttrib2dARB);
+        public static Delegates.VertexAttrib2dvARB_ VertexAttrib2dvARB_ = new Delegates.VertexAttrib2dvARB_(Imports.VertexAttrib2dvARB_);
+        public static Delegates.VertexAttrib2fARB VertexAttrib2fARB = new Delegates.VertexAttrib2fARB(Imports.VertexAttrib2fARB);
+        public static Delegates.VertexAttrib2fvARB_ VertexAttrib2fvARB_ = new Delegates.VertexAttrib2fvARB_(Imports.VertexAttrib2fvARB_);
+        public static Delegates.VertexAttrib2sARB VertexAttrib2sARB = new Delegates.VertexAttrib2sARB(Imports.VertexAttrib2sARB);
+        public static Delegates.VertexAttrib2svARB_ VertexAttrib2svARB_ = new Delegates.VertexAttrib2svARB_(Imports.VertexAttrib2svARB_);
+        public static Delegates.VertexAttrib3dARB VertexAttrib3dARB = new Delegates.VertexAttrib3dARB(Imports.VertexAttrib3dARB);
+        public static Delegates.VertexAttrib3dvARB_ VertexAttrib3dvARB_ = new Delegates.VertexAttrib3dvARB_(Imports.VertexAttrib3dvARB_);
+        public static Delegates.VertexAttrib3fARB VertexAttrib3fARB = new Delegates.VertexAttrib3fARB(Imports.VertexAttrib3fARB);
+        public static Delegates.VertexAttrib3fvARB_ VertexAttrib3fvARB_ = new Delegates.VertexAttrib3fvARB_(Imports.VertexAttrib3fvARB_);
+        public static Delegates.VertexAttrib3sARB VertexAttrib3sARB = new Delegates.VertexAttrib3sARB(Imports.VertexAttrib3sARB);
+        public static Delegates.VertexAttrib3svARB_ VertexAttrib3svARB_ = new Delegates.VertexAttrib3svARB_(Imports.VertexAttrib3svARB_);
+        public static Delegates.VertexAttrib4NbvARB_ VertexAttrib4NbvARB_ = new Delegates.VertexAttrib4NbvARB_(Imports.VertexAttrib4NbvARB_);
+        public static Delegates.VertexAttrib4NivARB_ VertexAttrib4NivARB_ = new Delegates.VertexAttrib4NivARB_(Imports.VertexAttrib4NivARB_);
+        public static Delegates.VertexAttrib4NsvARB_ VertexAttrib4NsvARB_ = new Delegates.VertexAttrib4NsvARB_(Imports.VertexAttrib4NsvARB_);
+        public static Delegates.VertexAttrib4NubARB VertexAttrib4NubARB = new Delegates.VertexAttrib4NubARB(Imports.VertexAttrib4NubARB);
+        public static Delegates.VertexAttrib4NubvARB_ VertexAttrib4NubvARB_ = new Delegates.VertexAttrib4NubvARB_(Imports.VertexAttrib4NubvARB_);
+        public static Delegates.VertexAttrib4NuivARB_ VertexAttrib4NuivARB_ = new Delegates.VertexAttrib4NuivARB_(Imports.VertexAttrib4NuivARB_);
+        public static Delegates.VertexAttrib4NusvARB_ VertexAttrib4NusvARB_ = new Delegates.VertexAttrib4NusvARB_(Imports.VertexAttrib4NusvARB_);
+        public static Delegates.VertexAttrib4bvARB_ VertexAttrib4bvARB_ = new Delegates.VertexAttrib4bvARB_(Imports.VertexAttrib4bvARB_);
+        public static Delegates.VertexAttrib4dARB VertexAttrib4dARB = new Delegates.VertexAttrib4dARB(Imports.VertexAttrib4dARB);
+        public static Delegates.VertexAttrib4dvARB_ VertexAttrib4dvARB_ = new Delegates.VertexAttrib4dvARB_(Imports.VertexAttrib4dvARB_);
+        public static Delegates.VertexAttrib4fARB VertexAttrib4fARB = new Delegates.VertexAttrib4fARB(Imports.VertexAttrib4fARB);
+        public static Delegates.VertexAttrib4fvARB_ VertexAttrib4fvARB_ = new Delegates.VertexAttrib4fvARB_(Imports.VertexAttrib4fvARB_);
+        public static Delegates.VertexAttrib4ivARB_ VertexAttrib4ivARB_ = new Delegates.VertexAttrib4ivARB_(Imports.VertexAttrib4ivARB_);
+        public static Delegates.VertexAttrib4sARB VertexAttrib4sARB = new Delegates.VertexAttrib4sARB(Imports.VertexAttrib4sARB);
+        public static Delegates.VertexAttrib4svARB_ VertexAttrib4svARB_ = new Delegates.VertexAttrib4svARB_(Imports.VertexAttrib4svARB_);
+        public static Delegates.VertexAttrib4ubvARB_ VertexAttrib4ubvARB_ = new Delegates.VertexAttrib4ubvARB_(Imports.VertexAttrib4ubvARB_);
+        public static Delegates.VertexAttrib4uivARB_ VertexAttrib4uivARB_ = new Delegates.VertexAttrib4uivARB_(Imports.VertexAttrib4uivARB_);
+        public static Delegates.VertexAttrib4usvARB_ VertexAttrib4usvARB_ = new Delegates.VertexAttrib4usvARB_(Imports.VertexAttrib4usvARB_);
+        public static Delegates.VertexAttribPointerARB_ VertexAttribPointerARB_ = new Delegates.VertexAttribPointerARB_(Imports.VertexAttribPointerARB_);
+        public static Delegates.EnableVertexAttribArrayARB EnableVertexAttribArrayARB = new Delegates.EnableVertexAttribArrayARB(Imports.EnableVertexAttribArrayARB);
+        public static Delegates.DisableVertexAttribArrayARB DisableVertexAttribArrayARB = new Delegates.DisableVertexAttribArrayARB(Imports.DisableVertexAttribArrayARB);
+        public static Delegates.ProgramStringARB_ ProgramStringARB_ = new Delegates.ProgramStringARB_(Imports.ProgramStringARB_);
+        public static Delegates.BindProgramARB BindProgramARB = new Delegates.BindProgramARB(Imports.BindProgramARB);
+        public static Delegates.DeleteProgramsARB_ DeleteProgramsARB_ = new Delegates.DeleteProgramsARB_(Imports.DeleteProgramsARB_);
+        public static Delegates.GenProgramsARB_ GenProgramsARB_ = new Delegates.GenProgramsARB_(Imports.GenProgramsARB_);
+        public static Delegates.ProgramEnvParameter4dARB ProgramEnvParameter4dARB = new Delegates.ProgramEnvParameter4dARB(Imports.ProgramEnvParameter4dARB);
+        public static Delegates.ProgramEnvParameter4dvARB_ ProgramEnvParameter4dvARB_ = new Delegates.ProgramEnvParameter4dvARB_(Imports.ProgramEnvParameter4dvARB_);
+        public static Delegates.ProgramEnvParameter4fARB ProgramEnvParameter4fARB = new Delegates.ProgramEnvParameter4fARB(Imports.ProgramEnvParameter4fARB);
+        public static Delegates.ProgramEnvParameter4fvARB_ ProgramEnvParameter4fvARB_ = new Delegates.ProgramEnvParameter4fvARB_(Imports.ProgramEnvParameter4fvARB_);
+        public static Delegates.ProgramLocalParameter4dARB ProgramLocalParameter4dARB = new Delegates.ProgramLocalParameter4dARB(Imports.ProgramLocalParameter4dARB);
+        public static Delegates.ProgramLocalParameter4dvARB_ ProgramLocalParameter4dvARB_ = new Delegates.ProgramLocalParameter4dvARB_(Imports.ProgramLocalParameter4dvARB_);
+        public static Delegates.ProgramLocalParameter4fARB ProgramLocalParameter4fARB = new Delegates.ProgramLocalParameter4fARB(Imports.ProgramLocalParameter4fARB);
+        public static Delegates.ProgramLocalParameter4fvARB_ ProgramLocalParameter4fvARB_ = new Delegates.ProgramLocalParameter4fvARB_(Imports.ProgramLocalParameter4fvARB_);
+        public static Delegates.GetProgramEnvParameterdvARB_ GetProgramEnvParameterdvARB_ = new Delegates.GetProgramEnvParameterdvARB_(Imports.GetProgramEnvParameterdvARB_);
+        public static Delegates.GetProgramEnvParameterfvARB_ GetProgramEnvParameterfvARB_ = new Delegates.GetProgramEnvParameterfvARB_(Imports.GetProgramEnvParameterfvARB_);
+        public static Delegates.GetProgramLocalParameterdvARB_ GetProgramLocalParameterdvARB_ = new Delegates.GetProgramLocalParameterdvARB_(Imports.GetProgramLocalParameterdvARB_);
+        public static Delegates.GetProgramLocalParameterfvARB_ GetProgramLocalParameterfvARB_ = new Delegates.GetProgramLocalParameterfvARB_(Imports.GetProgramLocalParameterfvARB_);
+        public static Delegates.GetProgramivARB_ GetProgramivARB_ = new Delegates.GetProgramivARB_(Imports.GetProgramivARB_);
+        public static Delegates.GetProgramStringARB_ GetProgramStringARB_ = new Delegates.GetProgramStringARB_(Imports.GetProgramStringARB_);
+        public static Delegates.GetVertexAttribdvARB_ GetVertexAttribdvARB_ = new Delegates.GetVertexAttribdvARB_(Imports.GetVertexAttribdvARB_);
+        public static Delegates.GetVertexAttribfvARB_ GetVertexAttribfvARB_ = new Delegates.GetVertexAttribfvARB_(Imports.GetVertexAttribfvARB_);
+        public static Delegates.GetVertexAttribivARB_ GetVertexAttribivARB_ = new Delegates.GetVertexAttribivARB_(Imports.GetVertexAttribivARB_);
+        public static Delegates.GetVertexAttribPointervARB_ GetVertexAttribPointervARB_ = new Delegates.GetVertexAttribPointervARB_(Imports.GetVertexAttribPointervARB_);
+        public static Delegates.IsProgramARB IsProgramARB = new Delegates.IsProgramARB(Imports.IsProgramARB);
+        public static Delegates.BindBufferARB BindBufferARB = new Delegates.BindBufferARB(Imports.BindBufferARB);
+        public static Delegates.DeleteBuffersARB_ DeleteBuffersARB_ = new Delegates.DeleteBuffersARB_(Imports.DeleteBuffersARB_);
+        public static Delegates.GenBuffersARB_ GenBuffersARB_ = new Delegates.GenBuffersARB_(Imports.GenBuffersARB_);
+        public static Delegates.IsBufferARB IsBufferARB = new Delegates.IsBufferARB(Imports.IsBufferARB);
+        public static Delegates.BufferDataARB_ BufferDataARB_ = new Delegates.BufferDataARB_(Imports.BufferDataARB_);
+        public static Delegates.BufferSubDataARB_ BufferSubDataARB_ = new Delegates.BufferSubDataARB_(Imports.BufferSubDataARB_);
+        public static Delegates.GetBufferSubDataARB_ GetBufferSubDataARB_ = new Delegates.GetBufferSubDataARB_(Imports.GetBufferSubDataARB_);
+        public static Delegates.MapBufferARB MapBufferARB = new Delegates.MapBufferARB(Imports.MapBufferARB);
+        public static Delegates.UnmapBufferARB UnmapBufferARB = new Delegates.UnmapBufferARB(Imports.UnmapBufferARB);
+        public static Delegates.GetBufferParameterivARB_ GetBufferParameterivARB_ = new Delegates.GetBufferParameterivARB_(Imports.GetBufferParameterivARB_);
+        public static Delegates.GetBufferPointervARB_ GetBufferPointervARB_ = new Delegates.GetBufferPointervARB_(Imports.GetBufferPointervARB_);
+        public static Delegates.GenQueriesARB_ GenQueriesARB_ = new Delegates.GenQueriesARB_(Imports.GenQueriesARB_);
+        public static Delegates.DeleteQueriesARB_ DeleteQueriesARB_ = new Delegates.DeleteQueriesARB_(Imports.DeleteQueriesARB_);
+        public static Delegates.IsQueryARB IsQueryARB = new Delegates.IsQueryARB(Imports.IsQueryARB);
+        public static Delegates.BeginQueryARB BeginQueryARB = new Delegates.BeginQueryARB(Imports.BeginQueryARB);
+        public static Delegates.EndQueryARB EndQueryARB = new Delegates.EndQueryARB(Imports.EndQueryARB);
+        public static Delegates.GetQueryivARB_ GetQueryivARB_ = new Delegates.GetQueryivARB_(Imports.GetQueryivARB_);
+        public static Delegates.GetQueryObjectivARB_ GetQueryObjectivARB_ = new Delegates.GetQueryObjectivARB_(Imports.GetQueryObjectivARB_);
+        public static Delegates.GetQueryObjectuivARB_ GetQueryObjectuivARB_ = new Delegates.GetQueryObjectuivARB_(Imports.GetQueryObjectuivARB_);
+        public static Delegates.DeleteObjectARB DeleteObjectARB = new Delegates.DeleteObjectARB(Imports.DeleteObjectARB);
+        public static Delegates.GetHandleARB GetHandleARB = new Delegates.GetHandleARB(Imports.GetHandleARB);
+        public static Delegates.DetachObjectARB DetachObjectARB = new Delegates.DetachObjectARB(Imports.DetachObjectARB);
+        public static Delegates.CreateShaderObjectARB CreateShaderObjectARB = new Delegates.CreateShaderObjectARB(Imports.CreateShaderObjectARB);
+        public static Delegates.ShaderSourceARB_ ShaderSourceARB_ = new Delegates.ShaderSourceARB_(Imports.ShaderSourceARB_);
+        public static Delegates.CompileShaderARB CompileShaderARB = new Delegates.CompileShaderARB(Imports.CompileShaderARB);
+        public static Delegates.CreateProgramObjectARB CreateProgramObjectARB = new Delegates.CreateProgramObjectARB(Imports.CreateProgramObjectARB);
+        public static Delegates.AttachObjectARB AttachObjectARB = new Delegates.AttachObjectARB(Imports.AttachObjectARB);
+        public static Delegates.LinkProgramARB LinkProgramARB = new Delegates.LinkProgramARB(Imports.LinkProgramARB);
+        public static Delegates.UseProgramObjectARB UseProgramObjectARB = new Delegates.UseProgramObjectARB(Imports.UseProgramObjectARB);
+        public static Delegates.ValidateProgramARB ValidateProgramARB = new Delegates.ValidateProgramARB(Imports.ValidateProgramARB);
+        public static Delegates.Uniform1fARB Uniform1fARB = new Delegates.Uniform1fARB(Imports.Uniform1fARB);
+        public static Delegates.Uniform2fARB Uniform2fARB = new Delegates.Uniform2fARB(Imports.Uniform2fARB);
+        public static Delegates.Uniform3fARB Uniform3fARB = new Delegates.Uniform3fARB(Imports.Uniform3fARB);
+        public static Delegates.Uniform4fARB Uniform4fARB = new Delegates.Uniform4fARB(Imports.Uniform4fARB);
+        public static Delegates.Uniform1iARB Uniform1iARB = new Delegates.Uniform1iARB(Imports.Uniform1iARB);
+        public static Delegates.Uniform2iARB Uniform2iARB = new Delegates.Uniform2iARB(Imports.Uniform2iARB);
+        public static Delegates.Uniform3iARB Uniform3iARB = new Delegates.Uniform3iARB(Imports.Uniform3iARB);
+        public static Delegates.Uniform4iARB Uniform4iARB = new Delegates.Uniform4iARB(Imports.Uniform4iARB);
+        public static Delegates.Uniform1fvARB_ Uniform1fvARB_ = new Delegates.Uniform1fvARB_(Imports.Uniform1fvARB_);
+        public static Delegates.Uniform2fvARB_ Uniform2fvARB_ = new Delegates.Uniform2fvARB_(Imports.Uniform2fvARB_);
+        public static Delegates.Uniform3fvARB_ Uniform3fvARB_ = new Delegates.Uniform3fvARB_(Imports.Uniform3fvARB_);
+        public static Delegates.Uniform4fvARB_ Uniform4fvARB_ = new Delegates.Uniform4fvARB_(Imports.Uniform4fvARB_);
+        public static Delegates.Uniform1ivARB_ Uniform1ivARB_ = new Delegates.Uniform1ivARB_(Imports.Uniform1ivARB_);
+        public static Delegates.Uniform2ivARB_ Uniform2ivARB_ = new Delegates.Uniform2ivARB_(Imports.Uniform2ivARB_);
+        public static Delegates.Uniform3ivARB_ Uniform3ivARB_ = new Delegates.Uniform3ivARB_(Imports.Uniform3ivARB_);
+        public static Delegates.Uniform4ivARB_ Uniform4ivARB_ = new Delegates.Uniform4ivARB_(Imports.Uniform4ivARB_);
+        public static Delegates.UniformMatrix2fvARB_ UniformMatrix2fvARB_ = new Delegates.UniformMatrix2fvARB_(Imports.UniformMatrix2fvARB_);
+        public static Delegates.UniformMatrix3fvARB_ UniformMatrix3fvARB_ = new Delegates.UniformMatrix3fvARB_(Imports.UniformMatrix3fvARB_);
+        public static Delegates.UniformMatrix4fvARB_ UniformMatrix4fvARB_ = new Delegates.UniformMatrix4fvARB_(Imports.UniformMatrix4fvARB_);
+        public static Delegates.GetObjectParameterfvARB_ GetObjectParameterfvARB_ = new Delegates.GetObjectParameterfvARB_(Imports.GetObjectParameterfvARB_);
+        public static Delegates.GetObjectParameterivARB_ GetObjectParameterivARB_ = new Delegates.GetObjectParameterivARB_(Imports.GetObjectParameterivARB_);
+        public static Delegates.GetInfoLogARB_ GetInfoLogARB_ = new Delegates.GetInfoLogARB_(Imports.GetInfoLogARB_);
+        public static Delegates.GetAttachedObjectsARB_ GetAttachedObjectsARB_ = new Delegates.GetAttachedObjectsARB_(Imports.GetAttachedObjectsARB_);
+        public static Delegates.GetUniformLocationARB GetUniformLocationARB = new Delegates.GetUniformLocationARB(Imports.GetUniformLocationARB);
+        public static Delegates.GetActiveUniformARB_ GetActiveUniformARB_ = new Delegates.GetActiveUniformARB_(Imports.GetActiveUniformARB_);
+        public static Delegates.GetUniformfvARB_ GetUniformfvARB_ = new Delegates.GetUniformfvARB_(Imports.GetUniformfvARB_);
+        public static Delegates.GetUniformivARB_ GetUniformivARB_ = new Delegates.GetUniformivARB_(Imports.GetUniformivARB_);
+        public static Delegates.GetShaderSourceARB_ GetShaderSourceARB_ = new Delegates.GetShaderSourceARB_(Imports.GetShaderSourceARB_);
+        public static Delegates.BindAttribLocationARB BindAttribLocationARB = new Delegates.BindAttribLocationARB(Imports.BindAttribLocationARB);
+        public static Delegates.GetActiveAttribARB_ GetActiveAttribARB_ = new Delegates.GetActiveAttribARB_(Imports.GetActiveAttribARB_);
+        public static Delegates.GetAttribLocationARB GetAttribLocationARB = new Delegates.GetAttribLocationARB(Imports.GetAttribLocationARB);
+        public static Delegates.DrawBuffersARB_ DrawBuffersARB_ = new Delegates.DrawBuffersARB_(Imports.DrawBuffersARB_);
+        public static Delegates.ClampColorARB ClampColorARB = new Delegates.ClampColorARB(Imports.ClampColorARB);
+        public static Delegates.BlendColorEXT BlendColorEXT = new Delegates.BlendColorEXT(Imports.BlendColorEXT);
+        public static Delegates.PolygonOffsetEXT PolygonOffsetEXT = new Delegates.PolygonOffsetEXT(Imports.PolygonOffsetEXT);
+        public static Delegates.TexImage3DEXT_ TexImage3DEXT_ = new Delegates.TexImage3DEXT_(Imports.TexImage3DEXT_);
+        public static Delegates.TexSubImage3DEXT_ TexSubImage3DEXT_ = new Delegates.TexSubImage3DEXT_(Imports.TexSubImage3DEXT_);
+        public static Delegates.GetTexFilterFuncSGIS_ GetTexFilterFuncSGIS_ = new Delegates.GetTexFilterFuncSGIS_(Imports.GetTexFilterFuncSGIS_);
+        public static Delegates.TexFilterFuncSGIS_ TexFilterFuncSGIS_ = new Delegates.TexFilterFuncSGIS_(Imports.TexFilterFuncSGIS_);
+        public static Delegates.TexSubImage1DEXT_ TexSubImage1DEXT_ = new Delegates.TexSubImage1DEXT_(Imports.TexSubImage1DEXT_);
+        public static Delegates.TexSubImage2DEXT_ TexSubImage2DEXT_ = new Delegates.TexSubImage2DEXT_(Imports.TexSubImage2DEXT_);
+        public static Delegates.CopyTexImage1DEXT CopyTexImage1DEXT = new Delegates.CopyTexImage1DEXT(Imports.CopyTexImage1DEXT);
+        public static Delegates.CopyTexImage2DEXT CopyTexImage2DEXT = new Delegates.CopyTexImage2DEXT(Imports.CopyTexImage2DEXT);
+        public static Delegates.CopyTexSubImage1DEXT CopyTexSubImage1DEXT = new Delegates.CopyTexSubImage1DEXT(Imports.CopyTexSubImage1DEXT);
+        public static Delegates.CopyTexSubImage2DEXT CopyTexSubImage2DEXT = new Delegates.CopyTexSubImage2DEXT(Imports.CopyTexSubImage2DEXT);
+        public static Delegates.CopyTexSubImage3DEXT CopyTexSubImage3DEXT = new Delegates.CopyTexSubImage3DEXT(Imports.CopyTexSubImage3DEXT);
+        public static Delegates.GetHistogramEXT_ GetHistogramEXT_ = new Delegates.GetHistogramEXT_(Imports.GetHistogramEXT_);
+        public static Delegates.GetHistogramParameterfvEXT_ GetHistogramParameterfvEXT_ = new Delegates.GetHistogramParameterfvEXT_(Imports.GetHistogramParameterfvEXT_);
+        public static Delegates.GetHistogramParameterivEXT_ GetHistogramParameterivEXT_ = new Delegates.GetHistogramParameterivEXT_(Imports.GetHistogramParameterivEXT_);
+        public static Delegates.GetMinmaxEXT_ GetMinmaxEXT_ = new Delegates.GetMinmaxEXT_(Imports.GetMinmaxEXT_);
+        public static Delegates.GetMinmaxParameterfvEXT_ GetMinmaxParameterfvEXT_ = new Delegates.GetMinmaxParameterfvEXT_(Imports.GetMinmaxParameterfvEXT_);
+        public static Delegates.GetMinmaxParameterivEXT_ GetMinmaxParameterivEXT_ = new Delegates.GetMinmaxParameterivEXT_(Imports.GetMinmaxParameterivEXT_);
+        public static Delegates.HistogramEXT HistogramEXT = new Delegates.HistogramEXT(Imports.HistogramEXT);
+        public static Delegates.MinmaxEXT MinmaxEXT = new Delegates.MinmaxEXT(Imports.MinmaxEXT);
+        public static Delegates.ResetHistogramEXT ResetHistogramEXT = new Delegates.ResetHistogramEXT(Imports.ResetHistogramEXT);
+        public static Delegates.ResetMinmaxEXT ResetMinmaxEXT = new Delegates.ResetMinmaxEXT(Imports.ResetMinmaxEXT);
+        public static Delegates.ConvolutionFilter1DEXT_ ConvolutionFilter1DEXT_ = new Delegates.ConvolutionFilter1DEXT_(Imports.ConvolutionFilter1DEXT_);
+        public static Delegates.ConvolutionFilter2DEXT_ ConvolutionFilter2DEXT_ = new Delegates.ConvolutionFilter2DEXT_(Imports.ConvolutionFilter2DEXT_);
+        public static Delegates.ConvolutionParameterfEXT ConvolutionParameterfEXT = new Delegates.ConvolutionParameterfEXT(Imports.ConvolutionParameterfEXT);
+        public static Delegates.ConvolutionParameterfvEXT_ ConvolutionParameterfvEXT_ = new Delegates.ConvolutionParameterfvEXT_(Imports.ConvolutionParameterfvEXT_);
+        public static Delegates.ConvolutionParameteriEXT ConvolutionParameteriEXT = new Delegates.ConvolutionParameteriEXT(Imports.ConvolutionParameteriEXT);
+        public static Delegates.ConvolutionParameterivEXT_ ConvolutionParameterivEXT_ = new Delegates.ConvolutionParameterivEXT_(Imports.ConvolutionParameterivEXT_);
+        public static Delegates.CopyConvolutionFilter1DEXT CopyConvolutionFilter1DEXT = new Delegates.CopyConvolutionFilter1DEXT(Imports.CopyConvolutionFilter1DEXT);
+        public static Delegates.CopyConvolutionFilter2DEXT CopyConvolutionFilter2DEXT = new Delegates.CopyConvolutionFilter2DEXT(Imports.CopyConvolutionFilter2DEXT);
+        public static Delegates.GetConvolutionFilterEXT_ GetConvolutionFilterEXT_ = new Delegates.GetConvolutionFilterEXT_(Imports.GetConvolutionFilterEXT_);
+        public static Delegates.GetConvolutionParameterfvEXT_ GetConvolutionParameterfvEXT_ = new Delegates.GetConvolutionParameterfvEXT_(Imports.GetConvolutionParameterfvEXT_);
+        public static Delegates.GetConvolutionParameterivEXT_ GetConvolutionParameterivEXT_ = new Delegates.GetConvolutionParameterivEXT_(Imports.GetConvolutionParameterivEXT_);
+        public static Delegates.GetSeparableFilterEXT_ GetSeparableFilterEXT_ = new Delegates.GetSeparableFilterEXT_(Imports.GetSeparableFilterEXT_);
+        public static Delegates.SeparableFilter2DEXT_ SeparableFilter2DEXT_ = new Delegates.SeparableFilter2DEXT_(Imports.SeparableFilter2DEXT_);
+        public static Delegates.ColorTableSGI_ ColorTableSGI_ = new Delegates.ColorTableSGI_(Imports.ColorTableSGI_);
+        public static Delegates.ColorTableParameterfvSGI_ ColorTableParameterfvSGI_ = new Delegates.ColorTableParameterfvSGI_(Imports.ColorTableParameterfvSGI_);
+        public static Delegates.ColorTableParameterivSGI_ ColorTableParameterivSGI_ = new Delegates.ColorTableParameterivSGI_(Imports.ColorTableParameterivSGI_);
+        public static Delegates.CopyColorTableSGI CopyColorTableSGI = new Delegates.CopyColorTableSGI(Imports.CopyColorTableSGI);
+        public static Delegates.GetColorTableSGI_ GetColorTableSGI_ = new Delegates.GetColorTableSGI_(Imports.GetColorTableSGI_);
+        public static Delegates.GetColorTableParameterfvSGI_ GetColorTableParameterfvSGI_ = new Delegates.GetColorTableParameterfvSGI_(Imports.GetColorTableParameterfvSGI_);
+        public static Delegates.GetColorTableParameterivSGI_ GetColorTableParameterivSGI_ = new Delegates.GetColorTableParameterivSGI_(Imports.GetColorTableParameterivSGI_);
+        public static Delegates.PixelTexGenSGIX PixelTexGenSGIX = new Delegates.PixelTexGenSGIX(Imports.PixelTexGenSGIX);
+        public static Delegates.PixelTexGenParameteriSGIS PixelTexGenParameteriSGIS = new Delegates.PixelTexGenParameteriSGIS(Imports.PixelTexGenParameteriSGIS);
+        public static Delegates.PixelTexGenParameterivSGIS_ PixelTexGenParameterivSGIS_ = new Delegates.PixelTexGenParameterivSGIS_(Imports.PixelTexGenParameterivSGIS_);
+        public static Delegates.PixelTexGenParameterfSGIS PixelTexGenParameterfSGIS = new Delegates.PixelTexGenParameterfSGIS(Imports.PixelTexGenParameterfSGIS);
+        public static Delegates.PixelTexGenParameterfvSGIS_ PixelTexGenParameterfvSGIS_ = new Delegates.PixelTexGenParameterfvSGIS_(Imports.PixelTexGenParameterfvSGIS_);
+        public static Delegates.GetPixelTexGenParameterivSGIS_ GetPixelTexGenParameterivSGIS_ = new Delegates.GetPixelTexGenParameterivSGIS_(Imports.GetPixelTexGenParameterivSGIS_);
+        public static Delegates.GetPixelTexGenParameterfvSGIS_ GetPixelTexGenParameterfvSGIS_ = new Delegates.GetPixelTexGenParameterfvSGIS_(Imports.GetPixelTexGenParameterfvSGIS_);
+        public static Delegates.TexImage4DSGIS_ TexImage4DSGIS_ = new Delegates.TexImage4DSGIS_(Imports.TexImage4DSGIS_);
+        public static Delegates.TexSubImage4DSGIS_ TexSubImage4DSGIS_ = new Delegates.TexSubImage4DSGIS_(Imports.TexSubImage4DSGIS_);
+        public static Delegates.AreTexturesResidentEXT_ AreTexturesResidentEXT_ = new Delegates.AreTexturesResidentEXT_(Imports.AreTexturesResidentEXT_);
+        public static Delegates.BindTextureEXT BindTextureEXT = new Delegates.BindTextureEXT(Imports.BindTextureEXT);
+        public static Delegates.DeleteTexturesEXT_ DeleteTexturesEXT_ = new Delegates.DeleteTexturesEXT_(Imports.DeleteTexturesEXT_);
+        public static Delegates.GenTexturesEXT_ GenTexturesEXT_ = new Delegates.GenTexturesEXT_(Imports.GenTexturesEXT_);
+        public static Delegates.IsTextureEXT IsTextureEXT = new Delegates.IsTextureEXT(Imports.IsTextureEXT);
+        public static Delegates.PrioritizeTexturesEXT_ PrioritizeTexturesEXT_ = new Delegates.PrioritizeTexturesEXT_(Imports.PrioritizeTexturesEXT_);
+        public static Delegates.DetailTexFuncSGIS_ DetailTexFuncSGIS_ = new Delegates.DetailTexFuncSGIS_(Imports.DetailTexFuncSGIS_);
+        public static Delegates.GetDetailTexFuncSGIS_ GetDetailTexFuncSGIS_ = new Delegates.GetDetailTexFuncSGIS_(Imports.GetDetailTexFuncSGIS_);
+        public static Delegates.SharpenTexFuncSGIS_ SharpenTexFuncSGIS_ = new Delegates.SharpenTexFuncSGIS_(Imports.SharpenTexFuncSGIS_);
+        public static Delegates.GetSharpenTexFuncSGIS_ GetSharpenTexFuncSGIS_ = new Delegates.GetSharpenTexFuncSGIS_(Imports.GetSharpenTexFuncSGIS_);
+        public static Delegates.SampleMaskSGIS SampleMaskSGIS = new Delegates.SampleMaskSGIS(Imports.SampleMaskSGIS);
+        public static Delegates.SamplePatternSGIS SamplePatternSGIS = new Delegates.SamplePatternSGIS(Imports.SamplePatternSGIS);
+        public static Delegates.ArrayElementEXT ArrayElementEXT = new Delegates.ArrayElementEXT(Imports.ArrayElementEXT);
+        public static Delegates.ColorPointerEXT_ ColorPointerEXT_ = new Delegates.ColorPointerEXT_(Imports.ColorPointerEXT_);
+        public static Delegates.DrawArraysEXT DrawArraysEXT = new Delegates.DrawArraysEXT(Imports.DrawArraysEXT);
+        public static Delegates.EdgeFlagPointerEXT_ EdgeFlagPointerEXT_ = new Delegates.EdgeFlagPointerEXT_(Imports.EdgeFlagPointerEXT_);
+        public static Delegates.GetPointervEXT_ GetPointervEXT_ = new Delegates.GetPointervEXT_(Imports.GetPointervEXT_);
+        public static Delegates.IndexPointerEXT_ IndexPointerEXT_ = new Delegates.IndexPointerEXT_(Imports.IndexPointerEXT_);
+        public static Delegates.NormalPointerEXT_ NormalPointerEXT_ = new Delegates.NormalPointerEXT_(Imports.NormalPointerEXT_);
+        public static Delegates.TexCoordPointerEXT_ TexCoordPointerEXT_ = new Delegates.TexCoordPointerEXT_(Imports.TexCoordPointerEXT_);
+        public static Delegates.VertexPointerEXT_ VertexPointerEXT_ = new Delegates.VertexPointerEXT_(Imports.VertexPointerEXT_);
+        public static Delegates.BlendEquationEXT BlendEquationEXT = new Delegates.BlendEquationEXT(Imports.BlendEquationEXT);
+        public static Delegates.SpriteParameterfSGIX SpriteParameterfSGIX = new Delegates.SpriteParameterfSGIX(Imports.SpriteParameterfSGIX);
+        public static Delegates.SpriteParameterfvSGIX_ SpriteParameterfvSGIX_ = new Delegates.SpriteParameterfvSGIX_(Imports.SpriteParameterfvSGIX_);
+        public static Delegates.SpriteParameteriSGIX SpriteParameteriSGIX = new Delegates.SpriteParameteriSGIX(Imports.SpriteParameteriSGIX);
+        public static Delegates.SpriteParameterivSGIX_ SpriteParameterivSGIX_ = new Delegates.SpriteParameterivSGIX_(Imports.SpriteParameterivSGIX_);
+        public static Delegates.PointParameterfEXT PointParameterfEXT = new Delegates.PointParameterfEXT(Imports.PointParameterfEXT);
+        public static Delegates.PointParameterfvEXT_ PointParameterfvEXT_ = new Delegates.PointParameterfvEXT_(Imports.PointParameterfvEXT_);
+        public static Delegates.PointParameterfSGIS PointParameterfSGIS = new Delegates.PointParameterfSGIS(Imports.PointParameterfSGIS);
+        public static Delegates.PointParameterfvSGIS_ PointParameterfvSGIS_ = new Delegates.PointParameterfvSGIS_(Imports.PointParameterfvSGIS_);
+        public static Delegates.GetInstrumentsSGIX GetInstrumentsSGIX = new Delegates.GetInstrumentsSGIX(Imports.GetInstrumentsSGIX);
+        public static Delegates.InstrumentsBufferSGIX_ InstrumentsBufferSGIX_ = new Delegates.InstrumentsBufferSGIX_(Imports.InstrumentsBufferSGIX_);
+        public static Delegates.PollInstrumentsSGIX_ PollInstrumentsSGIX_ = new Delegates.PollInstrumentsSGIX_(Imports.PollInstrumentsSGIX_);
+        public static Delegates.ReadInstrumentsSGIX ReadInstrumentsSGIX = new Delegates.ReadInstrumentsSGIX(Imports.ReadInstrumentsSGIX);
+        public static Delegates.StartInstrumentsSGIX StartInstrumentsSGIX = new Delegates.StartInstrumentsSGIX(Imports.StartInstrumentsSGIX);
+        public static Delegates.StopInstrumentsSGIX StopInstrumentsSGIX = new Delegates.StopInstrumentsSGIX(Imports.StopInstrumentsSGIX);
+        public static Delegates.FrameZoomSGIX FrameZoomSGIX = new Delegates.FrameZoomSGIX(Imports.FrameZoomSGIX);
+        public static Delegates.TagSampleBufferSGIX TagSampleBufferSGIX = new Delegates.TagSampleBufferSGIX(Imports.TagSampleBufferSGIX);
+        public static Delegates.DeformationMap3dSGIX_ DeformationMap3dSGIX_ = new Delegates.DeformationMap3dSGIX_(Imports.DeformationMap3dSGIX_);
+        public static Delegates.DeformationMap3fSGIX_ DeformationMap3fSGIX_ = new Delegates.DeformationMap3fSGIX_(Imports.DeformationMap3fSGIX_);
+        public static Delegates.DeformSGIX DeformSGIX = new Delegates.DeformSGIX(Imports.DeformSGIX);
+        public static Delegates.LoadIdentityDeformationMapSGIX LoadIdentityDeformationMapSGIX = new Delegates.LoadIdentityDeformationMapSGIX(Imports.LoadIdentityDeformationMapSGIX);
+        public static Delegates.ReferencePlaneSGIX_ ReferencePlaneSGIX_ = new Delegates.ReferencePlaneSGIX_(Imports.ReferencePlaneSGIX_);
+        public static Delegates.FlushRasterSGIX FlushRasterSGIX = new Delegates.FlushRasterSGIX(Imports.FlushRasterSGIX);
+        public static Delegates.FogFuncSGIS_ FogFuncSGIS_ = new Delegates.FogFuncSGIS_(Imports.FogFuncSGIS_);
+        public static Delegates.GetFogFuncSGIS_ GetFogFuncSGIS_ = new Delegates.GetFogFuncSGIS_(Imports.GetFogFuncSGIS_);
+        public static Delegates.ImageTransformParameteriHP ImageTransformParameteriHP = new Delegates.ImageTransformParameteriHP(Imports.ImageTransformParameteriHP);
+        public static Delegates.ImageTransformParameterfHP ImageTransformParameterfHP = new Delegates.ImageTransformParameterfHP(Imports.ImageTransformParameterfHP);
+        public static Delegates.ImageTransformParameterivHP_ ImageTransformParameterivHP_ = new Delegates.ImageTransformParameterivHP_(Imports.ImageTransformParameterivHP_);
+        public static Delegates.ImageTransformParameterfvHP_ ImageTransformParameterfvHP_ = new Delegates.ImageTransformParameterfvHP_(Imports.ImageTransformParameterfvHP_);
+        public static Delegates.GetImageTransformParameterivHP_ GetImageTransformParameterivHP_ = new Delegates.GetImageTransformParameterivHP_(Imports.GetImageTransformParameterivHP_);
+        public static Delegates.GetImageTransformParameterfvHP_ GetImageTransformParameterfvHP_ = new Delegates.GetImageTransformParameterfvHP_(Imports.GetImageTransformParameterfvHP_);
+        public static Delegates.ColorSubTableEXT_ ColorSubTableEXT_ = new Delegates.ColorSubTableEXT_(Imports.ColorSubTableEXT_);
+        public static Delegates.CopyColorSubTableEXT CopyColorSubTableEXT = new Delegates.CopyColorSubTableEXT(Imports.CopyColorSubTableEXT);
+        public static Delegates.HintPGI HintPGI = new Delegates.HintPGI(Imports.HintPGI);
+        public static Delegates.ColorTableEXT_ ColorTableEXT_ = new Delegates.ColorTableEXT_(Imports.ColorTableEXT_);
+        public static Delegates.GetColorTableEXT_ GetColorTableEXT_ = new Delegates.GetColorTableEXT_(Imports.GetColorTableEXT_);
+        public static Delegates.GetColorTableParameterivEXT_ GetColorTableParameterivEXT_ = new Delegates.GetColorTableParameterivEXT_(Imports.GetColorTableParameterivEXT_);
+        public static Delegates.GetColorTableParameterfvEXT_ GetColorTableParameterfvEXT_ = new Delegates.GetColorTableParameterfvEXT_(Imports.GetColorTableParameterfvEXT_);
+        public static Delegates.GetListParameterfvSGIX_ GetListParameterfvSGIX_ = new Delegates.GetListParameterfvSGIX_(Imports.GetListParameterfvSGIX_);
+        public static Delegates.GetListParameterivSGIX_ GetListParameterivSGIX_ = new Delegates.GetListParameterivSGIX_(Imports.GetListParameterivSGIX_);
+        public static Delegates.ListParameterfSGIX ListParameterfSGIX = new Delegates.ListParameterfSGIX(Imports.ListParameterfSGIX);
+        public static Delegates.ListParameterfvSGIX_ ListParameterfvSGIX_ = new Delegates.ListParameterfvSGIX_(Imports.ListParameterfvSGIX_);
+        public static Delegates.ListParameteriSGIX ListParameteriSGIX = new Delegates.ListParameteriSGIX(Imports.ListParameteriSGIX);
+        public static Delegates.ListParameterivSGIX_ ListParameterivSGIX_ = new Delegates.ListParameterivSGIX_(Imports.ListParameterivSGIX_);
+        public static Delegates.IndexMaterialEXT IndexMaterialEXT = new Delegates.IndexMaterialEXT(Imports.IndexMaterialEXT);
+        public static Delegates.IndexFuncEXT IndexFuncEXT = new Delegates.IndexFuncEXT(Imports.IndexFuncEXT);
+        public static Delegates.LockArraysEXT LockArraysEXT = new Delegates.LockArraysEXT(Imports.LockArraysEXT);
+        public static Delegates.UnlockArraysEXT UnlockArraysEXT = new Delegates.UnlockArraysEXT(Imports.UnlockArraysEXT);
+        public static Delegates.CullParameterdvEXT_ CullParameterdvEXT_ = new Delegates.CullParameterdvEXT_(Imports.CullParameterdvEXT_);
+        public static Delegates.CullParameterfvEXT_ CullParameterfvEXT_ = new Delegates.CullParameterfvEXT_(Imports.CullParameterfvEXT_);
+        public static Delegates.FragmentColorMaterialSGIX FragmentColorMaterialSGIX = new Delegates.FragmentColorMaterialSGIX(Imports.FragmentColorMaterialSGIX);
+        public static Delegates.FragmentLightfSGIX FragmentLightfSGIX = new Delegates.FragmentLightfSGIX(Imports.FragmentLightfSGIX);
+        public static Delegates.FragmentLightfvSGIX_ FragmentLightfvSGIX_ = new Delegates.FragmentLightfvSGIX_(Imports.FragmentLightfvSGIX_);
+        public static Delegates.FragmentLightiSGIX FragmentLightiSGIX = new Delegates.FragmentLightiSGIX(Imports.FragmentLightiSGIX);
+        public static Delegates.FragmentLightivSGIX_ FragmentLightivSGIX_ = new Delegates.FragmentLightivSGIX_(Imports.FragmentLightivSGIX_);
+        public static Delegates.FragmentLightModelfSGIX FragmentLightModelfSGIX = new Delegates.FragmentLightModelfSGIX(Imports.FragmentLightModelfSGIX);
+        public static Delegates.FragmentLightModelfvSGIX_ FragmentLightModelfvSGIX_ = new Delegates.FragmentLightModelfvSGIX_(Imports.FragmentLightModelfvSGIX_);
+        public static Delegates.FragmentLightModeliSGIX FragmentLightModeliSGIX = new Delegates.FragmentLightModeliSGIX(Imports.FragmentLightModeliSGIX);
+        public static Delegates.FragmentLightModelivSGIX_ FragmentLightModelivSGIX_ = new Delegates.FragmentLightModelivSGIX_(Imports.FragmentLightModelivSGIX_);
+        public static Delegates.FragmentMaterialfSGIX FragmentMaterialfSGIX = new Delegates.FragmentMaterialfSGIX(Imports.FragmentMaterialfSGIX);
+        public static Delegates.FragmentMaterialfvSGIX_ FragmentMaterialfvSGIX_ = new Delegates.FragmentMaterialfvSGIX_(Imports.FragmentMaterialfvSGIX_);
+        public static Delegates.FragmentMaterialiSGIX FragmentMaterialiSGIX = new Delegates.FragmentMaterialiSGIX(Imports.FragmentMaterialiSGIX);
+        public static Delegates.FragmentMaterialivSGIX_ FragmentMaterialivSGIX_ = new Delegates.FragmentMaterialivSGIX_(Imports.FragmentMaterialivSGIX_);
+        public static Delegates.GetFragmentLightfvSGIX_ GetFragmentLightfvSGIX_ = new Delegates.GetFragmentLightfvSGIX_(Imports.GetFragmentLightfvSGIX_);
+        public static Delegates.GetFragmentLightivSGIX_ GetFragmentLightivSGIX_ = new Delegates.GetFragmentLightivSGIX_(Imports.GetFragmentLightivSGIX_);
+        public static Delegates.GetFragmentMaterialfvSGIX_ GetFragmentMaterialfvSGIX_ = new Delegates.GetFragmentMaterialfvSGIX_(Imports.GetFragmentMaterialfvSGIX_);
+        public static Delegates.GetFragmentMaterialivSGIX_ GetFragmentMaterialivSGIX_ = new Delegates.GetFragmentMaterialivSGIX_(Imports.GetFragmentMaterialivSGIX_);
+        public static Delegates.LightEnviSGIX LightEnviSGIX = new Delegates.LightEnviSGIX(Imports.LightEnviSGIX);
+        public static Delegates.DrawRangeElementsEXT_ DrawRangeElementsEXT_ = new Delegates.DrawRangeElementsEXT_(Imports.DrawRangeElementsEXT_);
+        public static Delegates.ApplyTextureEXT ApplyTextureEXT = new Delegates.ApplyTextureEXT(Imports.ApplyTextureEXT);
+        public static Delegates.TextureLightEXT TextureLightEXT = new Delegates.TextureLightEXT(Imports.TextureLightEXT);
+        public static Delegates.TextureMaterialEXT TextureMaterialEXT = new Delegates.TextureMaterialEXT(Imports.TextureMaterialEXT);
+        public static Delegates.AsyncMarkerSGIX AsyncMarkerSGIX = new Delegates.AsyncMarkerSGIX(Imports.AsyncMarkerSGIX);
+        public static Delegates.FinishAsyncSGIX_ FinishAsyncSGIX_ = new Delegates.FinishAsyncSGIX_(Imports.FinishAsyncSGIX_);
+        public static Delegates.PollAsyncSGIX_ PollAsyncSGIX_ = new Delegates.PollAsyncSGIX_(Imports.PollAsyncSGIX_);
+        public static Delegates.GenAsyncMarkersSGIX GenAsyncMarkersSGIX = new Delegates.GenAsyncMarkersSGIX(Imports.GenAsyncMarkersSGIX);
+        public static Delegates.DeleteAsyncMarkersSGIX DeleteAsyncMarkersSGIX = new Delegates.DeleteAsyncMarkersSGIX(Imports.DeleteAsyncMarkersSGIX);
+        public static Delegates.IsAsyncMarkerSGIX IsAsyncMarkerSGIX = new Delegates.IsAsyncMarkerSGIX(Imports.IsAsyncMarkerSGIX);
+        public static Delegates.VertexPointervINTEL_ VertexPointervINTEL_ = new Delegates.VertexPointervINTEL_(Imports.VertexPointervINTEL_);
+        public static Delegates.NormalPointervINTEL_ NormalPointervINTEL_ = new Delegates.NormalPointervINTEL_(Imports.NormalPointervINTEL_);
+        public static Delegates.ColorPointervINTEL_ ColorPointervINTEL_ = new Delegates.ColorPointervINTEL_(Imports.ColorPointervINTEL_);
+        public static Delegates.TexCoordPointervINTEL_ TexCoordPointervINTEL_ = new Delegates.TexCoordPointervINTEL_(Imports.TexCoordPointervINTEL_);
+        public static Delegates.PixelTransformParameteriEXT PixelTransformParameteriEXT = new Delegates.PixelTransformParameteriEXT(Imports.PixelTransformParameteriEXT);
+        public static Delegates.PixelTransformParameterfEXT PixelTransformParameterfEXT = new Delegates.PixelTransformParameterfEXT(Imports.PixelTransformParameterfEXT);
+        public static Delegates.PixelTransformParameterivEXT_ PixelTransformParameterivEXT_ = new Delegates.PixelTransformParameterivEXT_(Imports.PixelTransformParameterivEXT_);
+        public static Delegates.PixelTransformParameterfvEXT_ PixelTransformParameterfvEXT_ = new Delegates.PixelTransformParameterfvEXT_(Imports.PixelTransformParameterfvEXT_);
+        public static Delegates.SecondaryColor3bEXT SecondaryColor3bEXT = new Delegates.SecondaryColor3bEXT(Imports.SecondaryColor3bEXT);
+        public static Delegates.SecondaryColor3bvEXT_ SecondaryColor3bvEXT_ = new Delegates.SecondaryColor3bvEXT_(Imports.SecondaryColor3bvEXT_);
+        public static Delegates.SecondaryColor3dEXT SecondaryColor3dEXT = new Delegates.SecondaryColor3dEXT(Imports.SecondaryColor3dEXT);
+        public static Delegates.SecondaryColor3dvEXT_ SecondaryColor3dvEXT_ = new Delegates.SecondaryColor3dvEXT_(Imports.SecondaryColor3dvEXT_);
+        public static Delegates.SecondaryColor3fEXT SecondaryColor3fEXT = new Delegates.SecondaryColor3fEXT(Imports.SecondaryColor3fEXT);
+        public static Delegates.SecondaryColor3fvEXT_ SecondaryColor3fvEXT_ = new Delegates.SecondaryColor3fvEXT_(Imports.SecondaryColor3fvEXT_);
+        public static Delegates.SecondaryColor3iEXT SecondaryColor3iEXT = new Delegates.SecondaryColor3iEXT(Imports.SecondaryColor3iEXT);
+        public static Delegates.SecondaryColor3ivEXT_ SecondaryColor3ivEXT_ = new Delegates.SecondaryColor3ivEXT_(Imports.SecondaryColor3ivEXT_);
+        public static Delegates.SecondaryColor3sEXT SecondaryColor3sEXT = new Delegates.SecondaryColor3sEXT(Imports.SecondaryColor3sEXT);
+        public static Delegates.SecondaryColor3svEXT_ SecondaryColor3svEXT_ = new Delegates.SecondaryColor3svEXT_(Imports.SecondaryColor3svEXT_);
+        public static Delegates.SecondaryColor3ubEXT SecondaryColor3ubEXT = new Delegates.SecondaryColor3ubEXT(Imports.SecondaryColor3ubEXT);
+        public static Delegates.SecondaryColor3ubvEXT_ SecondaryColor3ubvEXT_ = new Delegates.SecondaryColor3ubvEXT_(Imports.SecondaryColor3ubvEXT_);
+        public static Delegates.SecondaryColor3uiEXT SecondaryColor3uiEXT = new Delegates.SecondaryColor3uiEXT(Imports.SecondaryColor3uiEXT);
+        public static Delegates.SecondaryColor3uivEXT_ SecondaryColor3uivEXT_ = new Delegates.SecondaryColor3uivEXT_(Imports.SecondaryColor3uivEXT_);
+        public static Delegates.SecondaryColor3usEXT SecondaryColor3usEXT = new Delegates.SecondaryColor3usEXT(Imports.SecondaryColor3usEXT);
+        public static Delegates.SecondaryColor3usvEXT_ SecondaryColor3usvEXT_ = new Delegates.SecondaryColor3usvEXT_(Imports.SecondaryColor3usvEXT_);
+        public static Delegates.SecondaryColorPointerEXT_ SecondaryColorPointerEXT_ = new Delegates.SecondaryColorPointerEXT_(Imports.SecondaryColorPointerEXT_);
+        public static Delegates.TextureNormalEXT TextureNormalEXT = new Delegates.TextureNormalEXT(Imports.TextureNormalEXT);
+        public static Delegates.MultiDrawArraysEXT_ MultiDrawArraysEXT_ = new Delegates.MultiDrawArraysEXT_(Imports.MultiDrawArraysEXT_);
+        public static Delegates.MultiDrawElementsEXT_ MultiDrawElementsEXT_ = new Delegates.MultiDrawElementsEXT_(Imports.MultiDrawElementsEXT_);
+        public static Delegates.FogCoordfEXT FogCoordfEXT = new Delegates.FogCoordfEXT(Imports.FogCoordfEXT);
+        public static Delegates.FogCoordfvEXT_ FogCoordfvEXT_ = new Delegates.FogCoordfvEXT_(Imports.FogCoordfvEXT_);
+        public static Delegates.FogCoorddEXT FogCoorddEXT = new Delegates.FogCoorddEXT(Imports.FogCoorddEXT);
+        public static Delegates.FogCoorddvEXT_ FogCoorddvEXT_ = new Delegates.FogCoorddvEXT_(Imports.FogCoorddvEXT_);
+        public static Delegates.FogCoordPointerEXT_ FogCoordPointerEXT_ = new Delegates.FogCoordPointerEXT_(Imports.FogCoordPointerEXT_);
+        public static Delegates.Tangent3bEXT Tangent3bEXT = new Delegates.Tangent3bEXT(Imports.Tangent3bEXT);
+        public static Delegates.Tangent3bvEXT_ Tangent3bvEXT_ = new Delegates.Tangent3bvEXT_(Imports.Tangent3bvEXT_);
+        public static Delegates.Tangent3dEXT Tangent3dEXT = new Delegates.Tangent3dEXT(Imports.Tangent3dEXT);
+        public static Delegates.Tangent3dvEXT_ Tangent3dvEXT_ = new Delegates.Tangent3dvEXT_(Imports.Tangent3dvEXT_);
+        public static Delegates.Tangent3fEXT Tangent3fEXT = new Delegates.Tangent3fEXT(Imports.Tangent3fEXT);
+        public static Delegates.Tangent3fvEXT_ Tangent3fvEXT_ = new Delegates.Tangent3fvEXT_(Imports.Tangent3fvEXT_);
+        public static Delegates.Tangent3iEXT Tangent3iEXT = new Delegates.Tangent3iEXT(Imports.Tangent3iEXT);
+        public static Delegates.Tangent3ivEXT_ Tangent3ivEXT_ = new Delegates.Tangent3ivEXT_(Imports.Tangent3ivEXT_);
+        public static Delegates.Tangent3sEXT Tangent3sEXT = new Delegates.Tangent3sEXT(Imports.Tangent3sEXT);
+        public static Delegates.Tangent3svEXT_ Tangent3svEXT_ = new Delegates.Tangent3svEXT_(Imports.Tangent3svEXT_);
+        public static Delegates.Binormal3bEXT Binormal3bEXT = new Delegates.Binormal3bEXT(Imports.Binormal3bEXT);
+        public static Delegates.Binormal3bvEXT_ Binormal3bvEXT_ = new Delegates.Binormal3bvEXT_(Imports.Binormal3bvEXT_);
+        public static Delegates.Binormal3dEXT Binormal3dEXT = new Delegates.Binormal3dEXT(Imports.Binormal3dEXT);
+        public static Delegates.Binormal3dvEXT_ Binormal3dvEXT_ = new Delegates.Binormal3dvEXT_(Imports.Binormal3dvEXT_);
+        public static Delegates.Binormal3fEXT Binormal3fEXT = new Delegates.Binormal3fEXT(Imports.Binormal3fEXT);
+        public static Delegates.Binormal3fvEXT_ Binormal3fvEXT_ = new Delegates.Binormal3fvEXT_(Imports.Binormal3fvEXT_);
+        public static Delegates.Binormal3iEXT Binormal3iEXT = new Delegates.Binormal3iEXT(Imports.Binormal3iEXT);
+        public static Delegates.Binormal3ivEXT_ Binormal3ivEXT_ = new Delegates.Binormal3ivEXT_(Imports.Binormal3ivEXT_);
+        public static Delegates.Binormal3sEXT Binormal3sEXT = new Delegates.Binormal3sEXT(Imports.Binormal3sEXT);
+        public static Delegates.Binormal3svEXT_ Binormal3svEXT_ = new Delegates.Binormal3svEXT_(Imports.Binormal3svEXT_);
+        public static Delegates.TangentPointerEXT_ TangentPointerEXT_ = new Delegates.TangentPointerEXT_(Imports.TangentPointerEXT_);
+        public static Delegates.BinormalPointerEXT_ BinormalPointerEXT_ = new Delegates.BinormalPointerEXT_(Imports.BinormalPointerEXT_);
+        public static Delegates.FinishTextureSUNX FinishTextureSUNX = new Delegates.FinishTextureSUNX(Imports.FinishTextureSUNX);
+        public static Delegates.GlobalAlphaFactorbSUN GlobalAlphaFactorbSUN = new Delegates.GlobalAlphaFactorbSUN(Imports.GlobalAlphaFactorbSUN);
+        public static Delegates.GlobalAlphaFactorsSUN GlobalAlphaFactorsSUN = new Delegates.GlobalAlphaFactorsSUN(Imports.GlobalAlphaFactorsSUN);
+        public static Delegates.GlobalAlphaFactoriSUN GlobalAlphaFactoriSUN = new Delegates.GlobalAlphaFactoriSUN(Imports.GlobalAlphaFactoriSUN);
+        public static Delegates.GlobalAlphaFactorfSUN GlobalAlphaFactorfSUN = new Delegates.GlobalAlphaFactorfSUN(Imports.GlobalAlphaFactorfSUN);
+        public static Delegates.GlobalAlphaFactordSUN GlobalAlphaFactordSUN = new Delegates.GlobalAlphaFactordSUN(Imports.GlobalAlphaFactordSUN);
+        public static Delegates.GlobalAlphaFactorubSUN GlobalAlphaFactorubSUN = new Delegates.GlobalAlphaFactorubSUN(Imports.GlobalAlphaFactorubSUN);
+        public static Delegates.GlobalAlphaFactorusSUN GlobalAlphaFactorusSUN = new Delegates.GlobalAlphaFactorusSUN(Imports.GlobalAlphaFactorusSUN);
+        public static Delegates.GlobalAlphaFactoruiSUN GlobalAlphaFactoruiSUN = new Delegates.GlobalAlphaFactoruiSUN(Imports.GlobalAlphaFactoruiSUN);
+        public static Delegates.ReplacementCodeuiSUN ReplacementCodeuiSUN = new Delegates.ReplacementCodeuiSUN(Imports.ReplacementCodeuiSUN);
+        public static Delegates.ReplacementCodeusSUN ReplacementCodeusSUN = new Delegates.ReplacementCodeusSUN(Imports.ReplacementCodeusSUN);
+        public static Delegates.ReplacementCodeubSUN ReplacementCodeubSUN = new Delegates.ReplacementCodeubSUN(Imports.ReplacementCodeubSUN);
+        public static Delegates.ReplacementCodeuivSUN_ ReplacementCodeuivSUN_ = new Delegates.ReplacementCodeuivSUN_(Imports.ReplacementCodeuivSUN_);
+        public static Delegates.ReplacementCodeusvSUN_ ReplacementCodeusvSUN_ = new Delegates.ReplacementCodeusvSUN_(Imports.ReplacementCodeusvSUN_);
+        public static Delegates.ReplacementCodeubvSUN_ ReplacementCodeubvSUN_ = new Delegates.ReplacementCodeubvSUN_(Imports.ReplacementCodeubvSUN_);
+        public static Delegates.ReplacementCodePointerSUN_ ReplacementCodePointerSUN_ = new Delegates.ReplacementCodePointerSUN_(Imports.ReplacementCodePointerSUN_);
+        public static Delegates.Color4ubVertex2fSUN Color4ubVertex2fSUN = new Delegates.Color4ubVertex2fSUN(Imports.Color4ubVertex2fSUN);
+        public static Delegates.Color4ubVertex2fvSUN_ Color4ubVertex2fvSUN_ = new Delegates.Color4ubVertex2fvSUN_(Imports.Color4ubVertex2fvSUN_);
+        public static Delegates.Color4ubVertex3fSUN Color4ubVertex3fSUN = new Delegates.Color4ubVertex3fSUN(Imports.Color4ubVertex3fSUN);
+        public static Delegates.Color4ubVertex3fvSUN_ Color4ubVertex3fvSUN_ = new Delegates.Color4ubVertex3fvSUN_(Imports.Color4ubVertex3fvSUN_);
+        public static Delegates.Color3fVertex3fSUN Color3fVertex3fSUN = new Delegates.Color3fVertex3fSUN(Imports.Color3fVertex3fSUN);
+        public static Delegates.Color3fVertex3fvSUN_ Color3fVertex3fvSUN_ = new Delegates.Color3fVertex3fvSUN_(Imports.Color3fVertex3fvSUN_);
+        public static Delegates.Normal3fVertex3fSUN Normal3fVertex3fSUN = new Delegates.Normal3fVertex3fSUN(Imports.Normal3fVertex3fSUN);
+        public static Delegates.Normal3fVertex3fvSUN_ Normal3fVertex3fvSUN_ = new Delegates.Normal3fVertex3fvSUN_(Imports.Normal3fVertex3fvSUN_);
+        public static Delegates.Color4fNormal3fVertex3fSUN Color4fNormal3fVertex3fSUN = new Delegates.Color4fNormal3fVertex3fSUN(Imports.Color4fNormal3fVertex3fSUN);
+        public static Delegates.Color4fNormal3fVertex3fvSUN_ Color4fNormal3fVertex3fvSUN_ = new Delegates.Color4fNormal3fVertex3fvSUN_(Imports.Color4fNormal3fVertex3fvSUN_);
+        public static Delegates.TexCoord2fVertex3fSUN TexCoord2fVertex3fSUN = new Delegates.TexCoord2fVertex3fSUN(Imports.TexCoord2fVertex3fSUN);
+        public static Delegates.TexCoord2fVertex3fvSUN_ TexCoord2fVertex3fvSUN_ = new Delegates.TexCoord2fVertex3fvSUN_(Imports.TexCoord2fVertex3fvSUN_);
+        public static Delegates.TexCoord4fVertex4fSUN TexCoord4fVertex4fSUN = new Delegates.TexCoord4fVertex4fSUN(Imports.TexCoord4fVertex4fSUN);
+        public static Delegates.TexCoord4fVertex4fvSUN_ TexCoord4fVertex4fvSUN_ = new Delegates.TexCoord4fVertex4fvSUN_(Imports.TexCoord4fVertex4fvSUN_);
+        public static Delegates.TexCoord2fColor4ubVertex3fSUN TexCoord2fColor4ubVertex3fSUN = new Delegates.TexCoord2fColor4ubVertex3fSUN(Imports.TexCoord2fColor4ubVertex3fSUN);
+        public static Delegates.TexCoord2fColor4ubVertex3fvSUN_ TexCoord2fColor4ubVertex3fvSUN_ = new Delegates.TexCoord2fColor4ubVertex3fvSUN_(Imports.TexCoord2fColor4ubVertex3fvSUN_);
+        public static Delegates.TexCoord2fColor3fVertex3fSUN TexCoord2fColor3fVertex3fSUN = new Delegates.TexCoord2fColor3fVertex3fSUN(Imports.TexCoord2fColor3fVertex3fSUN);
+        public static Delegates.TexCoord2fColor3fVertex3fvSUN_ TexCoord2fColor3fVertex3fvSUN_ = new Delegates.TexCoord2fColor3fVertex3fvSUN_(Imports.TexCoord2fColor3fVertex3fvSUN_);
+        public static Delegates.TexCoord2fNormal3fVertex3fSUN TexCoord2fNormal3fVertex3fSUN = new Delegates.TexCoord2fNormal3fVertex3fSUN(Imports.TexCoord2fNormal3fVertex3fSUN);
+        public static Delegates.TexCoord2fNormal3fVertex3fvSUN_ TexCoord2fNormal3fVertex3fvSUN_ = new Delegates.TexCoord2fNormal3fVertex3fvSUN_(Imports.TexCoord2fNormal3fVertex3fvSUN_);
+        public static Delegates.TexCoord2fColor4fNormal3fVertex3fSUN TexCoord2fColor4fNormal3fVertex3fSUN = new Delegates.TexCoord2fColor4fNormal3fVertex3fSUN(Imports.TexCoord2fColor4fNormal3fVertex3fSUN);
+        public static Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN_ TexCoord2fColor4fNormal3fVertex3fvSUN_ = new Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN_(Imports.TexCoord2fColor4fNormal3fVertex3fvSUN_);
+        public static Delegates.TexCoord4fColor4fNormal3fVertex4fSUN TexCoord4fColor4fNormal3fVertex4fSUN = new Delegates.TexCoord4fColor4fNormal3fVertex4fSUN(Imports.TexCoord4fColor4fNormal3fVertex4fSUN);
+        public static Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN_ TexCoord4fColor4fNormal3fVertex4fvSUN_ = new Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN_(Imports.TexCoord4fColor4fNormal3fVertex4fvSUN_);
+        public static Delegates.ReplacementCodeuiVertex3fSUN ReplacementCodeuiVertex3fSUN = new Delegates.ReplacementCodeuiVertex3fSUN(Imports.ReplacementCodeuiVertex3fSUN);
+        public static Delegates.ReplacementCodeuiVertex3fvSUN_ ReplacementCodeuiVertex3fvSUN_ = new Delegates.ReplacementCodeuiVertex3fvSUN_(Imports.ReplacementCodeuiVertex3fvSUN_);
+        public static Delegates.ReplacementCodeuiColor4ubVertex3fSUN ReplacementCodeuiColor4ubVertex3fSUN = new Delegates.ReplacementCodeuiColor4ubVertex3fSUN(Imports.ReplacementCodeuiColor4ubVertex3fSUN);
+        public static Delegates.ReplacementCodeuiColor4ubVertex3fvSUN_ ReplacementCodeuiColor4ubVertex3fvSUN_ = new Delegates.ReplacementCodeuiColor4ubVertex3fvSUN_(Imports.ReplacementCodeuiColor4ubVertex3fvSUN_);
+        public static Delegates.ReplacementCodeuiColor3fVertex3fSUN ReplacementCodeuiColor3fVertex3fSUN = new Delegates.ReplacementCodeuiColor3fVertex3fSUN(Imports.ReplacementCodeuiColor3fVertex3fSUN);
+        public static Delegates.ReplacementCodeuiColor3fVertex3fvSUN_ ReplacementCodeuiColor3fVertex3fvSUN_ = new Delegates.ReplacementCodeuiColor3fVertex3fvSUN_(Imports.ReplacementCodeuiColor3fVertex3fvSUN_);
+        public static Delegates.ReplacementCodeuiNormal3fVertex3fSUN ReplacementCodeuiNormal3fVertex3fSUN = new Delegates.ReplacementCodeuiNormal3fVertex3fSUN(Imports.ReplacementCodeuiNormal3fVertex3fSUN);
+        public static Delegates.ReplacementCodeuiNormal3fVertex3fvSUN_ ReplacementCodeuiNormal3fVertex3fvSUN_ = new Delegates.ReplacementCodeuiNormal3fVertex3fvSUN_(Imports.ReplacementCodeuiNormal3fVertex3fvSUN_);
+        public static Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN ReplacementCodeuiColor4fNormal3fVertex3fSUN = new Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN(Imports.ReplacementCodeuiColor4fNormal3fVertex3fSUN);
+        public static Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ = new Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(Imports.ReplacementCodeuiColor4fNormal3fVertex3fvSUN_);
+        public static Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN ReplacementCodeuiTexCoord2fVertex3fSUN = new Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN(Imports.ReplacementCodeuiTexCoord2fVertex3fSUN);
+        public static Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN_ ReplacementCodeuiTexCoord2fVertex3fvSUN_ = new Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN_(Imports.ReplacementCodeuiTexCoord2fVertex3fvSUN_);
+        public static Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = new Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(Imports.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN);
+        public static Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ = new Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(Imports.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_);
+        public static Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = new Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(Imports.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN);
+        public static Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ = new Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(Imports.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_);
+        public static Delegates.BlendFuncSeparateEXT BlendFuncSeparateEXT = new Delegates.BlendFuncSeparateEXT(Imports.BlendFuncSeparateEXT);
+        public static Delegates.BlendFuncSeparateINGR BlendFuncSeparateINGR = new Delegates.BlendFuncSeparateINGR(Imports.BlendFuncSeparateINGR);
+        public static Delegates.VertexWeightfEXT VertexWeightfEXT = new Delegates.VertexWeightfEXT(Imports.VertexWeightfEXT);
+        public static Delegates.VertexWeightfvEXT_ VertexWeightfvEXT_ = new Delegates.VertexWeightfvEXT_(Imports.VertexWeightfvEXT_);
+        public static Delegates.VertexWeightPointerEXT_ VertexWeightPointerEXT_ = new Delegates.VertexWeightPointerEXT_(Imports.VertexWeightPointerEXT_);
+        public static Delegates.FlushVertexArrayRangeNV FlushVertexArrayRangeNV = new Delegates.FlushVertexArrayRangeNV(Imports.FlushVertexArrayRangeNV);
+        public static Delegates.VertexArrayRangeNV_ VertexArrayRangeNV_ = new Delegates.VertexArrayRangeNV_(Imports.VertexArrayRangeNV_);
+        public static Delegates.CombinerParameterfvNV_ CombinerParameterfvNV_ = new Delegates.CombinerParameterfvNV_(Imports.CombinerParameterfvNV_);
+        public static Delegates.CombinerParameterfNV CombinerParameterfNV = new Delegates.CombinerParameterfNV(Imports.CombinerParameterfNV);
+        public static Delegates.CombinerParameterivNV_ CombinerParameterivNV_ = new Delegates.CombinerParameterivNV_(Imports.CombinerParameterivNV_);
+        public static Delegates.CombinerParameteriNV CombinerParameteriNV = new Delegates.CombinerParameteriNV(Imports.CombinerParameteriNV);
+        public static Delegates.CombinerInputNV CombinerInputNV = new Delegates.CombinerInputNV(Imports.CombinerInputNV);
+        public static Delegates.CombinerOutputNV CombinerOutputNV = new Delegates.CombinerOutputNV(Imports.CombinerOutputNV);
+        public static Delegates.FinalCombinerInputNV FinalCombinerInputNV = new Delegates.FinalCombinerInputNV(Imports.FinalCombinerInputNV);
+        public static Delegates.GetCombinerInputParameterfvNV_ GetCombinerInputParameterfvNV_ = new Delegates.GetCombinerInputParameterfvNV_(Imports.GetCombinerInputParameterfvNV_);
+        public static Delegates.GetCombinerInputParameterivNV_ GetCombinerInputParameterivNV_ = new Delegates.GetCombinerInputParameterivNV_(Imports.GetCombinerInputParameterivNV_);
+        public static Delegates.GetCombinerOutputParameterfvNV_ GetCombinerOutputParameterfvNV_ = new Delegates.GetCombinerOutputParameterfvNV_(Imports.GetCombinerOutputParameterfvNV_);
+        public static Delegates.GetCombinerOutputParameterivNV_ GetCombinerOutputParameterivNV_ = new Delegates.GetCombinerOutputParameterivNV_(Imports.GetCombinerOutputParameterivNV_);
+        public static Delegates.GetFinalCombinerInputParameterfvNV_ GetFinalCombinerInputParameterfvNV_ = new Delegates.GetFinalCombinerInputParameterfvNV_(Imports.GetFinalCombinerInputParameterfvNV_);
+        public static Delegates.GetFinalCombinerInputParameterivNV_ GetFinalCombinerInputParameterivNV_ = new Delegates.GetFinalCombinerInputParameterivNV_(Imports.GetFinalCombinerInputParameterivNV_);
+        public static Delegates.ResizeBuffersMESA ResizeBuffersMESA = new Delegates.ResizeBuffersMESA(Imports.ResizeBuffersMESA);
+        public static Delegates.WindowPos2dMESA WindowPos2dMESA = new Delegates.WindowPos2dMESA(Imports.WindowPos2dMESA);
+        public static Delegates.WindowPos2dvMESA_ WindowPos2dvMESA_ = new Delegates.WindowPos2dvMESA_(Imports.WindowPos2dvMESA_);
+        public static Delegates.WindowPos2fMESA WindowPos2fMESA = new Delegates.WindowPos2fMESA(Imports.WindowPos2fMESA);
+        public static Delegates.WindowPos2fvMESA_ WindowPos2fvMESA_ = new Delegates.WindowPos2fvMESA_(Imports.WindowPos2fvMESA_);
+        public static Delegates.WindowPos2iMESA WindowPos2iMESA = new Delegates.WindowPos2iMESA(Imports.WindowPos2iMESA);
+        public static Delegates.WindowPos2ivMESA_ WindowPos2ivMESA_ = new Delegates.WindowPos2ivMESA_(Imports.WindowPos2ivMESA_);
+        public static Delegates.WindowPos2sMESA WindowPos2sMESA = new Delegates.WindowPos2sMESA(Imports.WindowPos2sMESA);
+        public static Delegates.WindowPos2svMESA_ WindowPos2svMESA_ = new Delegates.WindowPos2svMESA_(Imports.WindowPos2svMESA_);
+        public static Delegates.WindowPos3dMESA WindowPos3dMESA = new Delegates.WindowPos3dMESA(Imports.WindowPos3dMESA);
+        public static Delegates.WindowPos3dvMESA_ WindowPos3dvMESA_ = new Delegates.WindowPos3dvMESA_(Imports.WindowPos3dvMESA_);
+        public static Delegates.WindowPos3fMESA WindowPos3fMESA = new Delegates.WindowPos3fMESA(Imports.WindowPos3fMESA);
+        public static Delegates.WindowPos3fvMESA_ WindowPos3fvMESA_ = new Delegates.WindowPos3fvMESA_(Imports.WindowPos3fvMESA_);
+        public static Delegates.WindowPos3iMESA WindowPos3iMESA = new Delegates.WindowPos3iMESA(Imports.WindowPos3iMESA);
+        public static Delegates.WindowPos3ivMESA_ WindowPos3ivMESA_ = new Delegates.WindowPos3ivMESA_(Imports.WindowPos3ivMESA_);
+        public static Delegates.WindowPos3sMESA WindowPos3sMESA = new Delegates.WindowPos3sMESA(Imports.WindowPos3sMESA);
+        public static Delegates.WindowPos3svMESA_ WindowPos3svMESA_ = new Delegates.WindowPos3svMESA_(Imports.WindowPos3svMESA_);
+        public static Delegates.WindowPos4dMESA WindowPos4dMESA = new Delegates.WindowPos4dMESA(Imports.WindowPos4dMESA);
+        public static Delegates.WindowPos4dvMESA_ WindowPos4dvMESA_ = new Delegates.WindowPos4dvMESA_(Imports.WindowPos4dvMESA_);
+        public static Delegates.WindowPos4fMESA WindowPos4fMESA = new Delegates.WindowPos4fMESA(Imports.WindowPos4fMESA);
+        public static Delegates.WindowPos4fvMESA_ WindowPos4fvMESA_ = new Delegates.WindowPos4fvMESA_(Imports.WindowPos4fvMESA_);
+        public static Delegates.WindowPos4iMESA WindowPos4iMESA = new Delegates.WindowPos4iMESA(Imports.WindowPos4iMESA);
+        public static Delegates.WindowPos4ivMESA_ WindowPos4ivMESA_ = new Delegates.WindowPos4ivMESA_(Imports.WindowPos4ivMESA_);
+        public static Delegates.WindowPos4sMESA WindowPos4sMESA = new Delegates.WindowPos4sMESA(Imports.WindowPos4sMESA);
+        public static Delegates.WindowPos4svMESA_ WindowPos4svMESA_ = new Delegates.WindowPos4svMESA_(Imports.WindowPos4svMESA_);
+        public static Delegates.MultiModeDrawArraysIBM_ MultiModeDrawArraysIBM_ = new Delegates.MultiModeDrawArraysIBM_(Imports.MultiModeDrawArraysIBM_);
+        public static Delegates.MultiModeDrawElementsIBM_ MultiModeDrawElementsIBM_ = new Delegates.MultiModeDrawElementsIBM_(Imports.MultiModeDrawElementsIBM_);
+        public static Delegates.ColorPointerListIBM_ ColorPointerListIBM_ = new Delegates.ColorPointerListIBM_(Imports.ColorPointerListIBM_);
+        public static Delegates.SecondaryColorPointerListIBM_ SecondaryColorPointerListIBM_ = new Delegates.SecondaryColorPointerListIBM_(Imports.SecondaryColorPointerListIBM_);
+        public static Delegates.EdgeFlagPointerListIBM_ EdgeFlagPointerListIBM_ = new Delegates.EdgeFlagPointerListIBM_(Imports.EdgeFlagPointerListIBM_);
+        public static Delegates.FogCoordPointerListIBM_ FogCoordPointerListIBM_ = new Delegates.FogCoordPointerListIBM_(Imports.FogCoordPointerListIBM_);
+        public static Delegates.IndexPointerListIBM_ IndexPointerListIBM_ = new Delegates.IndexPointerListIBM_(Imports.IndexPointerListIBM_);
+        public static Delegates.NormalPointerListIBM_ NormalPointerListIBM_ = new Delegates.NormalPointerListIBM_(Imports.NormalPointerListIBM_);
+        public static Delegates.TexCoordPointerListIBM_ TexCoordPointerListIBM_ = new Delegates.TexCoordPointerListIBM_(Imports.TexCoordPointerListIBM_);
+        public static Delegates.VertexPointerListIBM_ VertexPointerListIBM_ = new Delegates.VertexPointerListIBM_(Imports.VertexPointerListIBM_);
+        public static Delegates.TbufferMask3DFX TbufferMask3DFX = new Delegates.TbufferMask3DFX(Imports.TbufferMask3DFX);
+        public static Delegates.SampleMaskEXT SampleMaskEXT = new Delegates.SampleMaskEXT(Imports.SampleMaskEXT);
+        public static Delegates.SamplePatternEXT SamplePatternEXT = new Delegates.SamplePatternEXT(Imports.SamplePatternEXT);
+        public static Delegates.TextureColorMaskSGIS TextureColorMaskSGIS = new Delegates.TextureColorMaskSGIS(Imports.TextureColorMaskSGIS);
+        public static Delegates.IglooInterfaceSGIX_ IglooInterfaceSGIX_ = new Delegates.IglooInterfaceSGIX_(Imports.IglooInterfaceSGIX_);
+        public static Delegates.DeleteFencesNV_ DeleteFencesNV_ = new Delegates.DeleteFencesNV_(Imports.DeleteFencesNV_);
+        public static Delegates.GenFencesNV_ GenFencesNV_ = new Delegates.GenFencesNV_(Imports.GenFencesNV_);
+        public static Delegates.IsFenceNV IsFenceNV = new Delegates.IsFenceNV(Imports.IsFenceNV);
+        public static Delegates.TestFenceNV TestFenceNV = new Delegates.TestFenceNV(Imports.TestFenceNV);
+        public static Delegates.GetFenceivNV_ GetFenceivNV_ = new Delegates.GetFenceivNV_(Imports.GetFenceivNV_);
+        public static Delegates.FinishFenceNV FinishFenceNV = new Delegates.FinishFenceNV(Imports.FinishFenceNV);
+        public static Delegates.SetFenceNV SetFenceNV = new Delegates.SetFenceNV(Imports.SetFenceNV);
+        public static Delegates.MapControlPointsNV_ MapControlPointsNV_ = new Delegates.MapControlPointsNV_(Imports.MapControlPointsNV_);
+        public static Delegates.MapParameterivNV_ MapParameterivNV_ = new Delegates.MapParameterivNV_(Imports.MapParameterivNV_);
+        public static Delegates.MapParameterfvNV_ MapParameterfvNV_ = new Delegates.MapParameterfvNV_(Imports.MapParameterfvNV_);
+        public static Delegates.GetMapControlPointsNV_ GetMapControlPointsNV_ = new Delegates.GetMapControlPointsNV_(Imports.GetMapControlPointsNV_);
+        public static Delegates.GetMapParameterivNV_ GetMapParameterivNV_ = new Delegates.GetMapParameterivNV_(Imports.GetMapParameterivNV_);
+        public static Delegates.GetMapParameterfvNV_ GetMapParameterfvNV_ = new Delegates.GetMapParameterfvNV_(Imports.GetMapParameterfvNV_);
+        public static Delegates.GetMapAttribParameterivNV_ GetMapAttribParameterivNV_ = new Delegates.GetMapAttribParameterivNV_(Imports.GetMapAttribParameterivNV_);
+        public static Delegates.GetMapAttribParameterfvNV_ GetMapAttribParameterfvNV_ = new Delegates.GetMapAttribParameterfvNV_(Imports.GetMapAttribParameterfvNV_);
+        public static Delegates.EvalMapsNV EvalMapsNV = new Delegates.EvalMapsNV(Imports.EvalMapsNV);
+        public static Delegates.CombinerStageParameterfvNV_ CombinerStageParameterfvNV_ = new Delegates.CombinerStageParameterfvNV_(Imports.CombinerStageParameterfvNV_);
+        public static Delegates.GetCombinerStageParameterfvNV_ GetCombinerStageParameterfvNV_ = new Delegates.GetCombinerStageParameterfvNV_(Imports.GetCombinerStageParameterfvNV_);
+        public static Delegates.AreProgramsResidentNV_ AreProgramsResidentNV_ = new Delegates.AreProgramsResidentNV_(Imports.AreProgramsResidentNV_);
+        public static Delegates.BindProgramNV BindProgramNV = new Delegates.BindProgramNV(Imports.BindProgramNV);
+        public static Delegates.DeleteProgramsNV_ DeleteProgramsNV_ = new Delegates.DeleteProgramsNV_(Imports.DeleteProgramsNV_);
+        public static Delegates.ExecuteProgramNV_ ExecuteProgramNV_ = new Delegates.ExecuteProgramNV_(Imports.ExecuteProgramNV_);
+        public static Delegates.GenProgramsNV_ GenProgramsNV_ = new Delegates.GenProgramsNV_(Imports.GenProgramsNV_);
+        public static Delegates.GetProgramParameterdvNV_ GetProgramParameterdvNV_ = new Delegates.GetProgramParameterdvNV_(Imports.GetProgramParameterdvNV_);
+        public static Delegates.GetProgramParameterfvNV_ GetProgramParameterfvNV_ = new Delegates.GetProgramParameterfvNV_(Imports.GetProgramParameterfvNV_);
+        public static Delegates.GetProgramivNV_ GetProgramivNV_ = new Delegates.GetProgramivNV_(Imports.GetProgramivNV_);
+        public static Delegates.GetProgramStringNV_ GetProgramStringNV_ = new Delegates.GetProgramStringNV_(Imports.GetProgramStringNV_);
+        public static Delegates.GetTrackMatrixivNV_ GetTrackMatrixivNV_ = new Delegates.GetTrackMatrixivNV_(Imports.GetTrackMatrixivNV_);
+        public static Delegates.GetVertexAttribdvNV_ GetVertexAttribdvNV_ = new Delegates.GetVertexAttribdvNV_(Imports.GetVertexAttribdvNV_);
+        public static Delegates.GetVertexAttribfvNV_ GetVertexAttribfvNV_ = new Delegates.GetVertexAttribfvNV_(Imports.GetVertexAttribfvNV_);
+        public static Delegates.GetVertexAttribivNV_ GetVertexAttribivNV_ = new Delegates.GetVertexAttribivNV_(Imports.GetVertexAttribivNV_);
+        public static Delegates.GetVertexAttribPointervNV_ GetVertexAttribPointervNV_ = new Delegates.GetVertexAttribPointervNV_(Imports.GetVertexAttribPointervNV_);
+        public static Delegates.IsProgramNV IsProgramNV = new Delegates.IsProgramNV(Imports.IsProgramNV);
+        public static Delegates.LoadProgramNV_ LoadProgramNV_ = new Delegates.LoadProgramNV_(Imports.LoadProgramNV_);
+        public static Delegates.ProgramParameter4dNV ProgramParameter4dNV = new Delegates.ProgramParameter4dNV(Imports.ProgramParameter4dNV);
+        public static Delegates.ProgramParameter4dvNV_ ProgramParameter4dvNV_ = new Delegates.ProgramParameter4dvNV_(Imports.ProgramParameter4dvNV_);
+        public static Delegates.ProgramParameter4fNV ProgramParameter4fNV = new Delegates.ProgramParameter4fNV(Imports.ProgramParameter4fNV);
+        public static Delegates.ProgramParameter4fvNV_ ProgramParameter4fvNV_ = new Delegates.ProgramParameter4fvNV_(Imports.ProgramParameter4fvNV_);
+        public static Delegates.ProgramParameters4dvNV_ ProgramParameters4dvNV_ = new Delegates.ProgramParameters4dvNV_(Imports.ProgramParameters4dvNV_);
+        public static Delegates.ProgramParameters4fvNV_ ProgramParameters4fvNV_ = new Delegates.ProgramParameters4fvNV_(Imports.ProgramParameters4fvNV_);
+        public static Delegates.RequestResidentProgramsNV_ RequestResidentProgramsNV_ = new Delegates.RequestResidentProgramsNV_(Imports.RequestResidentProgramsNV_);
+        public static Delegates.TrackMatrixNV TrackMatrixNV = new Delegates.TrackMatrixNV(Imports.TrackMatrixNV);
+        public static Delegates.VertexAttribPointerNV_ VertexAttribPointerNV_ = new Delegates.VertexAttribPointerNV_(Imports.VertexAttribPointerNV_);
+        public static Delegates.VertexAttrib1dNV VertexAttrib1dNV = new Delegates.VertexAttrib1dNV(Imports.VertexAttrib1dNV);
+        public static Delegates.VertexAttrib1dvNV_ VertexAttrib1dvNV_ = new Delegates.VertexAttrib1dvNV_(Imports.VertexAttrib1dvNV_);
+        public static Delegates.VertexAttrib1fNV VertexAttrib1fNV = new Delegates.VertexAttrib1fNV(Imports.VertexAttrib1fNV);
+        public static Delegates.VertexAttrib1fvNV_ VertexAttrib1fvNV_ = new Delegates.VertexAttrib1fvNV_(Imports.VertexAttrib1fvNV_);
+        public static Delegates.VertexAttrib1sNV VertexAttrib1sNV = new Delegates.VertexAttrib1sNV(Imports.VertexAttrib1sNV);
+        public static Delegates.VertexAttrib1svNV_ VertexAttrib1svNV_ = new Delegates.VertexAttrib1svNV_(Imports.VertexAttrib1svNV_);
+        public static Delegates.VertexAttrib2dNV VertexAttrib2dNV = new Delegates.VertexAttrib2dNV(Imports.VertexAttrib2dNV);
+        public static Delegates.VertexAttrib2dvNV_ VertexAttrib2dvNV_ = new Delegates.VertexAttrib2dvNV_(Imports.VertexAttrib2dvNV_);
+        public static Delegates.VertexAttrib2fNV VertexAttrib2fNV = new Delegates.VertexAttrib2fNV(Imports.VertexAttrib2fNV);
+        public static Delegates.VertexAttrib2fvNV_ VertexAttrib2fvNV_ = new Delegates.VertexAttrib2fvNV_(Imports.VertexAttrib2fvNV_);
+        public static Delegates.VertexAttrib2sNV VertexAttrib2sNV = new Delegates.VertexAttrib2sNV(Imports.VertexAttrib2sNV);
+        public static Delegates.VertexAttrib2svNV_ VertexAttrib2svNV_ = new Delegates.VertexAttrib2svNV_(Imports.VertexAttrib2svNV_);
+        public static Delegates.VertexAttrib3dNV VertexAttrib3dNV = new Delegates.VertexAttrib3dNV(Imports.VertexAttrib3dNV);
+        public static Delegates.VertexAttrib3dvNV_ VertexAttrib3dvNV_ = new Delegates.VertexAttrib3dvNV_(Imports.VertexAttrib3dvNV_);
+        public static Delegates.VertexAttrib3fNV VertexAttrib3fNV = new Delegates.VertexAttrib3fNV(Imports.VertexAttrib3fNV);
+        public static Delegates.VertexAttrib3fvNV_ VertexAttrib3fvNV_ = new Delegates.VertexAttrib3fvNV_(Imports.VertexAttrib3fvNV_);
+        public static Delegates.VertexAttrib3sNV VertexAttrib3sNV = new Delegates.VertexAttrib3sNV(Imports.VertexAttrib3sNV);
+        public static Delegates.VertexAttrib3svNV_ VertexAttrib3svNV_ = new Delegates.VertexAttrib3svNV_(Imports.VertexAttrib3svNV_);
+        public static Delegates.VertexAttrib4dNV VertexAttrib4dNV = new Delegates.VertexAttrib4dNV(Imports.VertexAttrib4dNV);
+        public static Delegates.VertexAttrib4dvNV_ VertexAttrib4dvNV_ = new Delegates.VertexAttrib4dvNV_(Imports.VertexAttrib4dvNV_);
+        public static Delegates.VertexAttrib4fNV VertexAttrib4fNV = new Delegates.VertexAttrib4fNV(Imports.VertexAttrib4fNV);
+        public static Delegates.VertexAttrib4fvNV_ VertexAttrib4fvNV_ = new Delegates.VertexAttrib4fvNV_(Imports.VertexAttrib4fvNV_);
+        public static Delegates.VertexAttrib4sNV VertexAttrib4sNV = new Delegates.VertexAttrib4sNV(Imports.VertexAttrib4sNV);
+        public static Delegates.VertexAttrib4svNV_ VertexAttrib4svNV_ = new Delegates.VertexAttrib4svNV_(Imports.VertexAttrib4svNV_);
+        public static Delegates.VertexAttrib4ubNV VertexAttrib4ubNV = new Delegates.VertexAttrib4ubNV(Imports.VertexAttrib4ubNV);
+        public static Delegates.VertexAttrib4ubvNV_ VertexAttrib4ubvNV_ = new Delegates.VertexAttrib4ubvNV_(Imports.VertexAttrib4ubvNV_);
+        public static Delegates.VertexAttribs1dvNV_ VertexAttribs1dvNV_ = new Delegates.VertexAttribs1dvNV_(Imports.VertexAttribs1dvNV_);
+        public static Delegates.VertexAttribs1fvNV_ VertexAttribs1fvNV_ = new Delegates.VertexAttribs1fvNV_(Imports.VertexAttribs1fvNV_);
+        public static Delegates.VertexAttribs1svNV_ VertexAttribs1svNV_ = new Delegates.VertexAttribs1svNV_(Imports.VertexAttribs1svNV_);
+        public static Delegates.VertexAttribs2dvNV_ VertexAttribs2dvNV_ = new Delegates.VertexAttribs2dvNV_(Imports.VertexAttribs2dvNV_);
+        public static Delegates.VertexAttribs2fvNV_ VertexAttribs2fvNV_ = new Delegates.VertexAttribs2fvNV_(Imports.VertexAttribs2fvNV_);
+        public static Delegates.VertexAttribs2svNV_ VertexAttribs2svNV_ = new Delegates.VertexAttribs2svNV_(Imports.VertexAttribs2svNV_);
+        public static Delegates.VertexAttribs3dvNV_ VertexAttribs3dvNV_ = new Delegates.VertexAttribs3dvNV_(Imports.VertexAttribs3dvNV_);
+        public static Delegates.VertexAttribs3fvNV_ VertexAttribs3fvNV_ = new Delegates.VertexAttribs3fvNV_(Imports.VertexAttribs3fvNV_);
+        public static Delegates.VertexAttribs3svNV_ VertexAttribs3svNV_ = new Delegates.VertexAttribs3svNV_(Imports.VertexAttribs3svNV_);
+        public static Delegates.VertexAttribs4dvNV_ VertexAttribs4dvNV_ = new Delegates.VertexAttribs4dvNV_(Imports.VertexAttribs4dvNV_);
+        public static Delegates.VertexAttribs4fvNV_ VertexAttribs4fvNV_ = new Delegates.VertexAttribs4fvNV_(Imports.VertexAttribs4fvNV_);
+        public static Delegates.VertexAttribs4svNV_ VertexAttribs4svNV_ = new Delegates.VertexAttribs4svNV_(Imports.VertexAttribs4svNV_);
+        public static Delegates.VertexAttribs4ubvNV_ VertexAttribs4ubvNV_ = new Delegates.VertexAttribs4ubvNV_(Imports.VertexAttribs4ubvNV_);
+        public static Delegates.TexBumpParameterivATI_ TexBumpParameterivATI_ = new Delegates.TexBumpParameterivATI_(Imports.TexBumpParameterivATI_);
+        public static Delegates.TexBumpParameterfvATI_ TexBumpParameterfvATI_ = new Delegates.TexBumpParameterfvATI_(Imports.TexBumpParameterfvATI_);
+        public static Delegates.GetTexBumpParameterivATI_ GetTexBumpParameterivATI_ = new Delegates.GetTexBumpParameterivATI_(Imports.GetTexBumpParameterivATI_);
+        public static Delegates.GetTexBumpParameterfvATI_ GetTexBumpParameterfvATI_ = new Delegates.GetTexBumpParameterfvATI_(Imports.GetTexBumpParameterfvATI_);
+        public static Delegates.GenFragmentShadersATI GenFragmentShadersATI = new Delegates.GenFragmentShadersATI(Imports.GenFragmentShadersATI);
+        public static Delegates.BindFragmentShaderATI BindFragmentShaderATI = new Delegates.BindFragmentShaderATI(Imports.BindFragmentShaderATI);
+        public static Delegates.DeleteFragmentShaderATI DeleteFragmentShaderATI = new Delegates.DeleteFragmentShaderATI(Imports.DeleteFragmentShaderATI);
+        public static Delegates.BeginFragmentShaderATI BeginFragmentShaderATI = new Delegates.BeginFragmentShaderATI(Imports.BeginFragmentShaderATI);
+        public static Delegates.EndFragmentShaderATI EndFragmentShaderATI = new Delegates.EndFragmentShaderATI(Imports.EndFragmentShaderATI);
+        public static Delegates.PassTexCoordATI PassTexCoordATI = new Delegates.PassTexCoordATI(Imports.PassTexCoordATI);
+        public static Delegates.SampleMapATI SampleMapATI = new Delegates.SampleMapATI(Imports.SampleMapATI);
+        public static Delegates.ColorFragmentOp1ATI ColorFragmentOp1ATI = new Delegates.ColorFragmentOp1ATI(Imports.ColorFragmentOp1ATI);
+        public static Delegates.ColorFragmentOp2ATI ColorFragmentOp2ATI = new Delegates.ColorFragmentOp2ATI(Imports.ColorFragmentOp2ATI);
+        public static Delegates.ColorFragmentOp3ATI ColorFragmentOp3ATI = new Delegates.ColorFragmentOp3ATI(Imports.ColorFragmentOp3ATI);
+        public static Delegates.AlphaFragmentOp1ATI AlphaFragmentOp1ATI = new Delegates.AlphaFragmentOp1ATI(Imports.AlphaFragmentOp1ATI);
+        public static Delegates.AlphaFragmentOp2ATI AlphaFragmentOp2ATI = new Delegates.AlphaFragmentOp2ATI(Imports.AlphaFragmentOp2ATI);
+        public static Delegates.AlphaFragmentOp3ATI AlphaFragmentOp3ATI = new Delegates.AlphaFragmentOp3ATI(Imports.AlphaFragmentOp3ATI);
+        public static Delegates.SetFragmentShaderConstantATI_ SetFragmentShaderConstantATI_ = new Delegates.SetFragmentShaderConstantATI_(Imports.SetFragmentShaderConstantATI_);
+        public static Delegates.PNTrianglesiATI PNTrianglesiATI = new Delegates.PNTrianglesiATI(Imports.PNTrianglesiATI);
+        public static Delegates.PNTrianglesfATI PNTrianglesfATI = new Delegates.PNTrianglesfATI(Imports.PNTrianglesfATI);
+        public static Delegates.NewObjectBufferATI_ NewObjectBufferATI_ = new Delegates.NewObjectBufferATI_(Imports.NewObjectBufferATI_);
+        public static Delegates.IsObjectBufferATI IsObjectBufferATI = new Delegates.IsObjectBufferATI(Imports.IsObjectBufferATI);
+        public static Delegates.UpdateObjectBufferATI_ UpdateObjectBufferATI_ = new Delegates.UpdateObjectBufferATI_(Imports.UpdateObjectBufferATI_);
+        public static Delegates.GetObjectBufferfvATI_ GetObjectBufferfvATI_ = new Delegates.GetObjectBufferfvATI_(Imports.GetObjectBufferfvATI_);
+        public static Delegates.GetObjectBufferivATI_ GetObjectBufferivATI_ = new Delegates.GetObjectBufferivATI_(Imports.GetObjectBufferivATI_);
+        public static Delegates.FreeObjectBufferATI FreeObjectBufferATI = new Delegates.FreeObjectBufferATI(Imports.FreeObjectBufferATI);
+        public static Delegates.ArrayObjectATI ArrayObjectATI = new Delegates.ArrayObjectATI(Imports.ArrayObjectATI);
+        public static Delegates.GetArrayObjectfvATI_ GetArrayObjectfvATI_ = new Delegates.GetArrayObjectfvATI_(Imports.GetArrayObjectfvATI_);
+        public static Delegates.GetArrayObjectivATI_ GetArrayObjectivATI_ = new Delegates.GetArrayObjectivATI_(Imports.GetArrayObjectivATI_);
+        public static Delegates.VariantArrayObjectATI VariantArrayObjectATI = new Delegates.VariantArrayObjectATI(Imports.VariantArrayObjectATI);
+        public static Delegates.GetVariantArrayObjectfvATI_ GetVariantArrayObjectfvATI_ = new Delegates.GetVariantArrayObjectfvATI_(Imports.GetVariantArrayObjectfvATI_);
+        public static Delegates.GetVariantArrayObjectivATI_ GetVariantArrayObjectivATI_ = new Delegates.GetVariantArrayObjectivATI_(Imports.GetVariantArrayObjectivATI_);
+        public static Delegates.BeginVertexShaderEXT BeginVertexShaderEXT = new Delegates.BeginVertexShaderEXT(Imports.BeginVertexShaderEXT);
+        public static Delegates.EndVertexShaderEXT EndVertexShaderEXT = new Delegates.EndVertexShaderEXT(Imports.EndVertexShaderEXT);
+        public static Delegates.BindVertexShaderEXT BindVertexShaderEXT = new Delegates.BindVertexShaderEXT(Imports.BindVertexShaderEXT);
+        public static Delegates.GenVertexShadersEXT GenVertexShadersEXT = new Delegates.GenVertexShadersEXT(Imports.GenVertexShadersEXT);
+        public static Delegates.DeleteVertexShaderEXT DeleteVertexShaderEXT = new Delegates.DeleteVertexShaderEXT(Imports.DeleteVertexShaderEXT);
+        public static Delegates.ShaderOp1EXT ShaderOp1EXT = new Delegates.ShaderOp1EXT(Imports.ShaderOp1EXT);
+        public static Delegates.ShaderOp2EXT ShaderOp2EXT = new Delegates.ShaderOp2EXT(Imports.ShaderOp2EXT);
+        public static Delegates.ShaderOp3EXT ShaderOp3EXT = new Delegates.ShaderOp3EXT(Imports.ShaderOp3EXT);
+        public static Delegates.SwizzleEXT SwizzleEXT = new Delegates.SwizzleEXT(Imports.SwizzleEXT);
+        public static Delegates.WriteMaskEXT WriteMaskEXT = new Delegates.WriteMaskEXT(Imports.WriteMaskEXT);
+        public static Delegates.InsertComponentEXT InsertComponentEXT = new Delegates.InsertComponentEXT(Imports.InsertComponentEXT);
+        public static Delegates.ExtractComponentEXT ExtractComponentEXT = new Delegates.ExtractComponentEXT(Imports.ExtractComponentEXT);
+        public static Delegates.GenSymbolsEXT GenSymbolsEXT = new Delegates.GenSymbolsEXT(Imports.GenSymbolsEXT);
+        public static Delegates.SetInvariantEXT_ SetInvariantEXT_ = new Delegates.SetInvariantEXT_(Imports.SetInvariantEXT_);
+        public static Delegates.SetLocalConstantEXT_ SetLocalConstantEXT_ = new Delegates.SetLocalConstantEXT_(Imports.SetLocalConstantEXT_);
+        public static Delegates.VariantbvEXT_ VariantbvEXT_ = new Delegates.VariantbvEXT_(Imports.VariantbvEXT_);
+        public static Delegates.VariantsvEXT_ VariantsvEXT_ = new Delegates.VariantsvEXT_(Imports.VariantsvEXT_);
+        public static Delegates.VariantivEXT_ VariantivEXT_ = new Delegates.VariantivEXT_(Imports.VariantivEXT_);
+        public static Delegates.VariantfvEXT_ VariantfvEXT_ = new Delegates.VariantfvEXT_(Imports.VariantfvEXT_);
+        public static Delegates.VariantdvEXT_ VariantdvEXT_ = new Delegates.VariantdvEXT_(Imports.VariantdvEXT_);
+        public static Delegates.VariantubvEXT_ VariantubvEXT_ = new Delegates.VariantubvEXT_(Imports.VariantubvEXT_);
+        public static Delegates.VariantusvEXT_ VariantusvEXT_ = new Delegates.VariantusvEXT_(Imports.VariantusvEXT_);
+        public static Delegates.VariantuivEXT_ VariantuivEXT_ = new Delegates.VariantuivEXT_(Imports.VariantuivEXT_);
+        public static Delegates.VariantPointerEXT_ VariantPointerEXT_ = new Delegates.VariantPointerEXT_(Imports.VariantPointerEXT_);
+        public static Delegates.EnableVariantClientStateEXT EnableVariantClientStateEXT = new Delegates.EnableVariantClientStateEXT(Imports.EnableVariantClientStateEXT);
+        public static Delegates.DisableVariantClientStateEXT DisableVariantClientStateEXT = new Delegates.DisableVariantClientStateEXT(Imports.DisableVariantClientStateEXT);
+        public static Delegates.BindLightParameterEXT BindLightParameterEXT = new Delegates.BindLightParameterEXT(Imports.BindLightParameterEXT);
+        public static Delegates.BindMaterialParameterEXT BindMaterialParameterEXT = new Delegates.BindMaterialParameterEXT(Imports.BindMaterialParameterEXT);
+        public static Delegates.BindTexGenParameterEXT BindTexGenParameterEXT = new Delegates.BindTexGenParameterEXT(Imports.BindTexGenParameterEXT);
+        public static Delegates.BindTextureUnitParameterEXT BindTextureUnitParameterEXT = new Delegates.BindTextureUnitParameterEXT(Imports.BindTextureUnitParameterEXT);
+        public static Delegates.BindParameterEXT BindParameterEXT = new Delegates.BindParameterEXT(Imports.BindParameterEXT);
+        public static Delegates.IsVariantEnabledEXT IsVariantEnabledEXT = new Delegates.IsVariantEnabledEXT(Imports.IsVariantEnabledEXT);
+        public static Delegates.GetVariantBooleanvEXT_ GetVariantBooleanvEXT_ = new Delegates.GetVariantBooleanvEXT_(Imports.GetVariantBooleanvEXT_);
+        public static Delegates.GetVariantIntegervEXT_ GetVariantIntegervEXT_ = new Delegates.GetVariantIntegervEXT_(Imports.GetVariantIntegervEXT_);
+        public static Delegates.GetVariantFloatvEXT_ GetVariantFloatvEXT_ = new Delegates.GetVariantFloatvEXT_(Imports.GetVariantFloatvEXT_);
+        public static Delegates.GetVariantPointervEXT_ GetVariantPointervEXT_ = new Delegates.GetVariantPointervEXT_(Imports.GetVariantPointervEXT_);
+        public static Delegates.GetInvariantBooleanvEXT_ GetInvariantBooleanvEXT_ = new Delegates.GetInvariantBooleanvEXT_(Imports.GetInvariantBooleanvEXT_);
+        public static Delegates.GetInvariantIntegervEXT_ GetInvariantIntegervEXT_ = new Delegates.GetInvariantIntegervEXT_(Imports.GetInvariantIntegervEXT_);
+        public static Delegates.GetInvariantFloatvEXT_ GetInvariantFloatvEXT_ = new Delegates.GetInvariantFloatvEXT_(Imports.GetInvariantFloatvEXT_);
+        public static Delegates.GetLocalConstantBooleanvEXT_ GetLocalConstantBooleanvEXT_ = new Delegates.GetLocalConstantBooleanvEXT_(Imports.GetLocalConstantBooleanvEXT_);
+        public static Delegates.GetLocalConstantIntegervEXT_ GetLocalConstantIntegervEXT_ = new Delegates.GetLocalConstantIntegervEXT_(Imports.GetLocalConstantIntegervEXT_);
+        public static Delegates.GetLocalConstantFloatvEXT_ GetLocalConstantFloatvEXT_ = new Delegates.GetLocalConstantFloatvEXT_(Imports.GetLocalConstantFloatvEXT_);
+        public static Delegates.VertexStream1sATI VertexStream1sATI = new Delegates.VertexStream1sATI(Imports.VertexStream1sATI);
+        public static Delegates.VertexStream1svATI_ VertexStream1svATI_ = new Delegates.VertexStream1svATI_(Imports.VertexStream1svATI_);
+        public static Delegates.VertexStream1iATI VertexStream1iATI = new Delegates.VertexStream1iATI(Imports.VertexStream1iATI);
+        public static Delegates.VertexStream1ivATI_ VertexStream1ivATI_ = new Delegates.VertexStream1ivATI_(Imports.VertexStream1ivATI_);
+        public static Delegates.VertexStream1fATI VertexStream1fATI = new Delegates.VertexStream1fATI(Imports.VertexStream1fATI);
+        public static Delegates.VertexStream1fvATI_ VertexStream1fvATI_ = new Delegates.VertexStream1fvATI_(Imports.VertexStream1fvATI_);
+        public static Delegates.VertexStream1dATI VertexStream1dATI = new Delegates.VertexStream1dATI(Imports.VertexStream1dATI);
+        public static Delegates.VertexStream1dvATI_ VertexStream1dvATI_ = new Delegates.VertexStream1dvATI_(Imports.VertexStream1dvATI_);
+        public static Delegates.VertexStream2sATI VertexStream2sATI = new Delegates.VertexStream2sATI(Imports.VertexStream2sATI);
+        public static Delegates.VertexStream2svATI_ VertexStream2svATI_ = new Delegates.VertexStream2svATI_(Imports.VertexStream2svATI_);
+        public static Delegates.VertexStream2iATI VertexStream2iATI = new Delegates.VertexStream2iATI(Imports.VertexStream2iATI);
+        public static Delegates.VertexStream2ivATI_ VertexStream2ivATI_ = new Delegates.VertexStream2ivATI_(Imports.VertexStream2ivATI_);
+        public static Delegates.VertexStream2fATI VertexStream2fATI = new Delegates.VertexStream2fATI(Imports.VertexStream2fATI);
+        public static Delegates.VertexStream2fvATI_ VertexStream2fvATI_ = new Delegates.VertexStream2fvATI_(Imports.VertexStream2fvATI_);
+        public static Delegates.VertexStream2dATI VertexStream2dATI = new Delegates.VertexStream2dATI(Imports.VertexStream2dATI);
+        public static Delegates.VertexStream2dvATI_ VertexStream2dvATI_ = new Delegates.VertexStream2dvATI_(Imports.VertexStream2dvATI_);
+        public static Delegates.VertexStream3sATI VertexStream3sATI = new Delegates.VertexStream3sATI(Imports.VertexStream3sATI);
+        public static Delegates.VertexStream3svATI_ VertexStream3svATI_ = new Delegates.VertexStream3svATI_(Imports.VertexStream3svATI_);
+        public static Delegates.VertexStream3iATI VertexStream3iATI = new Delegates.VertexStream3iATI(Imports.VertexStream3iATI);
+        public static Delegates.VertexStream3ivATI_ VertexStream3ivATI_ = new Delegates.VertexStream3ivATI_(Imports.VertexStream3ivATI_);
+        public static Delegates.VertexStream3fATI VertexStream3fATI = new Delegates.VertexStream3fATI(Imports.VertexStream3fATI);
+        public static Delegates.VertexStream3fvATI_ VertexStream3fvATI_ = new Delegates.VertexStream3fvATI_(Imports.VertexStream3fvATI_);
+        public static Delegates.VertexStream3dATI VertexStream3dATI = new Delegates.VertexStream3dATI(Imports.VertexStream3dATI);
+        public static Delegates.VertexStream3dvATI_ VertexStream3dvATI_ = new Delegates.VertexStream3dvATI_(Imports.VertexStream3dvATI_);
+        public static Delegates.VertexStream4sATI VertexStream4sATI = new Delegates.VertexStream4sATI(Imports.VertexStream4sATI);
+        public static Delegates.VertexStream4svATI_ VertexStream4svATI_ = new Delegates.VertexStream4svATI_(Imports.VertexStream4svATI_);
+        public static Delegates.VertexStream4iATI VertexStream4iATI = new Delegates.VertexStream4iATI(Imports.VertexStream4iATI);
+        public static Delegates.VertexStream4ivATI_ VertexStream4ivATI_ = new Delegates.VertexStream4ivATI_(Imports.VertexStream4ivATI_);
+        public static Delegates.VertexStream4fATI VertexStream4fATI = new Delegates.VertexStream4fATI(Imports.VertexStream4fATI);
+        public static Delegates.VertexStream4fvATI_ VertexStream4fvATI_ = new Delegates.VertexStream4fvATI_(Imports.VertexStream4fvATI_);
+        public static Delegates.VertexStream4dATI VertexStream4dATI = new Delegates.VertexStream4dATI(Imports.VertexStream4dATI);
+        public static Delegates.VertexStream4dvATI_ VertexStream4dvATI_ = new Delegates.VertexStream4dvATI_(Imports.VertexStream4dvATI_);
+        public static Delegates.NormalStream3bATI NormalStream3bATI = new Delegates.NormalStream3bATI(Imports.NormalStream3bATI);
+        public static Delegates.NormalStream3bvATI_ NormalStream3bvATI_ = new Delegates.NormalStream3bvATI_(Imports.NormalStream3bvATI_);
+        public static Delegates.NormalStream3sATI NormalStream3sATI = new Delegates.NormalStream3sATI(Imports.NormalStream3sATI);
+        public static Delegates.NormalStream3svATI_ NormalStream3svATI_ = new Delegates.NormalStream3svATI_(Imports.NormalStream3svATI_);
+        public static Delegates.NormalStream3iATI NormalStream3iATI = new Delegates.NormalStream3iATI(Imports.NormalStream3iATI);
+        public static Delegates.NormalStream3ivATI_ NormalStream3ivATI_ = new Delegates.NormalStream3ivATI_(Imports.NormalStream3ivATI_);
+        public static Delegates.NormalStream3fATI NormalStream3fATI = new Delegates.NormalStream3fATI(Imports.NormalStream3fATI);
+        public static Delegates.NormalStream3fvATI_ NormalStream3fvATI_ = new Delegates.NormalStream3fvATI_(Imports.NormalStream3fvATI_);
+        public static Delegates.NormalStream3dATI NormalStream3dATI = new Delegates.NormalStream3dATI(Imports.NormalStream3dATI);
+        public static Delegates.NormalStream3dvATI_ NormalStream3dvATI_ = new Delegates.NormalStream3dvATI_(Imports.NormalStream3dvATI_);
+        public static Delegates.ClientActiveVertexStreamATI ClientActiveVertexStreamATI = new Delegates.ClientActiveVertexStreamATI(Imports.ClientActiveVertexStreamATI);
+        public static Delegates.VertexBlendEnviATI VertexBlendEnviATI = new Delegates.VertexBlendEnviATI(Imports.VertexBlendEnviATI);
+        public static Delegates.VertexBlendEnvfATI VertexBlendEnvfATI = new Delegates.VertexBlendEnvfATI(Imports.VertexBlendEnvfATI);
+        public static Delegates.ElementPointerATI_ ElementPointerATI_ = new Delegates.ElementPointerATI_(Imports.ElementPointerATI_);
+        public static Delegates.DrawElementArrayATI DrawElementArrayATI = new Delegates.DrawElementArrayATI(Imports.DrawElementArrayATI);
+        public static Delegates.DrawRangeElementArrayATI DrawRangeElementArrayATI = new Delegates.DrawRangeElementArrayATI(Imports.DrawRangeElementArrayATI);
+        public static Delegates.DrawMeshArraysSUN DrawMeshArraysSUN = new Delegates.DrawMeshArraysSUN(Imports.DrawMeshArraysSUN);
+        public static Delegates.GenOcclusionQueriesNV_ GenOcclusionQueriesNV_ = new Delegates.GenOcclusionQueriesNV_(Imports.GenOcclusionQueriesNV_);
+        public static Delegates.DeleteOcclusionQueriesNV_ DeleteOcclusionQueriesNV_ = new Delegates.DeleteOcclusionQueriesNV_(Imports.DeleteOcclusionQueriesNV_);
+        public static Delegates.IsOcclusionQueryNV IsOcclusionQueryNV = new Delegates.IsOcclusionQueryNV(Imports.IsOcclusionQueryNV);
+        public static Delegates.BeginOcclusionQueryNV BeginOcclusionQueryNV = new Delegates.BeginOcclusionQueryNV(Imports.BeginOcclusionQueryNV);
+        public static Delegates.EndOcclusionQueryNV EndOcclusionQueryNV = new Delegates.EndOcclusionQueryNV(Imports.EndOcclusionQueryNV);
+        public static Delegates.GetOcclusionQueryivNV_ GetOcclusionQueryivNV_ = new Delegates.GetOcclusionQueryivNV_(Imports.GetOcclusionQueryivNV_);
+        public static Delegates.GetOcclusionQueryuivNV_ GetOcclusionQueryuivNV_ = new Delegates.GetOcclusionQueryuivNV_(Imports.GetOcclusionQueryuivNV_);
+        public static Delegates.PointParameteriNV PointParameteriNV = new Delegates.PointParameteriNV(Imports.PointParameteriNV);
+        public static Delegates.PointParameterivNV_ PointParameterivNV_ = new Delegates.PointParameterivNV_(Imports.PointParameterivNV_);
+        public static Delegates.ActiveStencilFaceEXT ActiveStencilFaceEXT = new Delegates.ActiveStencilFaceEXT(Imports.ActiveStencilFaceEXT);
+        public static Delegates.ElementPointerAPPLE_ ElementPointerAPPLE_ = new Delegates.ElementPointerAPPLE_(Imports.ElementPointerAPPLE_);
+        public static Delegates.DrawElementArrayAPPLE DrawElementArrayAPPLE = new Delegates.DrawElementArrayAPPLE(Imports.DrawElementArrayAPPLE);
+        public static Delegates.DrawRangeElementArrayAPPLE DrawRangeElementArrayAPPLE = new Delegates.DrawRangeElementArrayAPPLE(Imports.DrawRangeElementArrayAPPLE);
+        public static Delegates.MultiDrawElementArrayAPPLE_ MultiDrawElementArrayAPPLE_ = new Delegates.MultiDrawElementArrayAPPLE_(Imports.MultiDrawElementArrayAPPLE_);
+        public static Delegates.MultiDrawRangeElementArrayAPPLE_ MultiDrawRangeElementArrayAPPLE_ = new Delegates.MultiDrawRangeElementArrayAPPLE_(Imports.MultiDrawRangeElementArrayAPPLE_);
+        public static Delegates.GenFencesAPPLE_ GenFencesAPPLE_ = new Delegates.GenFencesAPPLE_(Imports.GenFencesAPPLE_);
+        public static Delegates.DeleteFencesAPPLE_ DeleteFencesAPPLE_ = new Delegates.DeleteFencesAPPLE_(Imports.DeleteFencesAPPLE_);
+        public static Delegates.SetFenceAPPLE SetFenceAPPLE = new Delegates.SetFenceAPPLE(Imports.SetFenceAPPLE);
+        public static Delegates.IsFenceAPPLE IsFenceAPPLE = new Delegates.IsFenceAPPLE(Imports.IsFenceAPPLE);
+        public static Delegates.TestFenceAPPLE TestFenceAPPLE = new Delegates.TestFenceAPPLE(Imports.TestFenceAPPLE);
+        public static Delegates.FinishFenceAPPLE FinishFenceAPPLE = new Delegates.FinishFenceAPPLE(Imports.FinishFenceAPPLE);
+        public static Delegates.TestObjectAPPLE TestObjectAPPLE = new Delegates.TestObjectAPPLE(Imports.TestObjectAPPLE);
+        public static Delegates.FinishObjectAPPLE FinishObjectAPPLE = new Delegates.FinishObjectAPPLE(Imports.FinishObjectAPPLE);
+        public static Delegates.BindVertexArrayAPPLE BindVertexArrayAPPLE = new Delegates.BindVertexArrayAPPLE(Imports.BindVertexArrayAPPLE);
+        public static Delegates.DeleteVertexArraysAPPLE_ DeleteVertexArraysAPPLE_ = new Delegates.DeleteVertexArraysAPPLE_(Imports.DeleteVertexArraysAPPLE_);
+        public static Delegates.GenVertexArraysAPPLE_ GenVertexArraysAPPLE_ = new Delegates.GenVertexArraysAPPLE_(Imports.GenVertexArraysAPPLE_);
+        public static Delegates.IsVertexArrayAPPLE IsVertexArrayAPPLE = new Delegates.IsVertexArrayAPPLE(Imports.IsVertexArrayAPPLE);
+        public static Delegates.VertexArrayRangeAPPLE_ VertexArrayRangeAPPLE_ = new Delegates.VertexArrayRangeAPPLE_(Imports.VertexArrayRangeAPPLE_);
+        public static Delegates.FlushVertexArrayRangeAPPLE_ FlushVertexArrayRangeAPPLE_ = new Delegates.FlushVertexArrayRangeAPPLE_(Imports.FlushVertexArrayRangeAPPLE_);
+        public static Delegates.VertexArrayParameteriAPPLE VertexArrayParameteriAPPLE = new Delegates.VertexArrayParameteriAPPLE(Imports.VertexArrayParameteriAPPLE);
+        public static Delegates.DrawBuffersATI_ DrawBuffersATI_ = new Delegates.DrawBuffersATI_(Imports.DrawBuffersATI_);
+        public static Delegates.ProgramNamedParameter4fNV_ ProgramNamedParameter4fNV_ = new Delegates.ProgramNamedParameter4fNV_(Imports.ProgramNamedParameter4fNV_);
+        public static Delegates.ProgramNamedParameter4dNV_ ProgramNamedParameter4dNV_ = new Delegates.ProgramNamedParameter4dNV_(Imports.ProgramNamedParameter4dNV_);
+        public static Delegates.ProgramNamedParameter4fvNV_ ProgramNamedParameter4fvNV_ = new Delegates.ProgramNamedParameter4fvNV_(Imports.ProgramNamedParameter4fvNV_);
+        public static Delegates.ProgramNamedParameter4dvNV_ ProgramNamedParameter4dvNV_ = new Delegates.ProgramNamedParameter4dvNV_(Imports.ProgramNamedParameter4dvNV_);
+        public static Delegates.GetProgramNamedParameterfvNV_ GetProgramNamedParameterfvNV_ = new Delegates.GetProgramNamedParameterfvNV_(Imports.GetProgramNamedParameterfvNV_);
+        public static Delegates.GetProgramNamedParameterdvNV_ GetProgramNamedParameterdvNV_ = new Delegates.GetProgramNamedParameterdvNV_(Imports.GetProgramNamedParameterdvNV_);
+        public static Delegates.Vertex2hNV Vertex2hNV = new Delegates.Vertex2hNV(Imports.Vertex2hNV);
+        public static Delegates.Vertex2hvNV_ Vertex2hvNV_ = new Delegates.Vertex2hvNV_(Imports.Vertex2hvNV_);
+        public static Delegates.Vertex3hNV Vertex3hNV = new Delegates.Vertex3hNV(Imports.Vertex3hNV);
+        public static Delegates.Vertex3hvNV_ Vertex3hvNV_ = new Delegates.Vertex3hvNV_(Imports.Vertex3hvNV_);
+        public static Delegates.Vertex4hNV Vertex4hNV = new Delegates.Vertex4hNV(Imports.Vertex4hNV);
+        public static Delegates.Vertex4hvNV_ Vertex4hvNV_ = new Delegates.Vertex4hvNV_(Imports.Vertex4hvNV_);
+        public static Delegates.Normal3hNV Normal3hNV = new Delegates.Normal3hNV(Imports.Normal3hNV);
+        public static Delegates.Normal3hvNV_ Normal3hvNV_ = new Delegates.Normal3hvNV_(Imports.Normal3hvNV_);
+        public static Delegates.Color3hNV Color3hNV = new Delegates.Color3hNV(Imports.Color3hNV);
+        public static Delegates.Color3hvNV_ Color3hvNV_ = new Delegates.Color3hvNV_(Imports.Color3hvNV_);
+        public static Delegates.Color4hNV Color4hNV = new Delegates.Color4hNV(Imports.Color4hNV);
+        public static Delegates.Color4hvNV_ Color4hvNV_ = new Delegates.Color4hvNV_(Imports.Color4hvNV_);
+        public static Delegates.TexCoord1hNV TexCoord1hNV = new Delegates.TexCoord1hNV(Imports.TexCoord1hNV);
+        public static Delegates.TexCoord1hvNV_ TexCoord1hvNV_ = new Delegates.TexCoord1hvNV_(Imports.TexCoord1hvNV_);
+        public static Delegates.TexCoord2hNV TexCoord2hNV = new Delegates.TexCoord2hNV(Imports.TexCoord2hNV);
+        public static Delegates.TexCoord2hvNV_ TexCoord2hvNV_ = new Delegates.TexCoord2hvNV_(Imports.TexCoord2hvNV_);
+        public static Delegates.TexCoord3hNV TexCoord3hNV = new Delegates.TexCoord3hNV(Imports.TexCoord3hNV);
+        public static Delegates.TexCoord3hvNV_ TexCoord3hvNV_ = new Delegates.TexCoord3hvNV_(Imports.TexCoord3hvNV_);
+        public static Delegates.TexCoord4hNV TexCoord4hNV = new Delegates.TexCoord4hNV(Imports.TexCoord4hNV);
+        public static Delegates.TexCoord4hvNV_ TexCoord4hvNV_ = new Delegates.TexCoord4hvNV_(Imports.TexCoord4hvNV_);
+        public static Delegates.MultiTexCoord1hNV MultiTexCoord1hNV = new Delegates.MultiTexCoord1hNV(Imports.MultiTexCoord1hNV);
+        public static Delegates.MultiTexCoord1hvNV_ MultiTexCoord1hvNV_ = new Delegates.MultiTexCoord1hvNV_(Imports.MultiTexCoord1hvNV_);
+        public static Delegates.MultiTexCoord2hNV MultiTexCoord2hNV = new Delegates.MultiTexCoord2hNV(Imports.MultiTexCoord2hNV);
+        public static Delegates.MultiTexCoord2hvNV_ MultiTexCoord2hvNV_ = new Delegates.MultiTexCoord2hvNV_(Imports.MultiTexCoord2hvNV_);
+        public static Delegates.MultiTexCoord3hNV MultiTexCoord3hNV = new Delegates.MultiTexCoord3hNV(Imports.MultiTexCoord3hNV);
+        public static Delegates.MultiTexCoord3hvNV_ MultiTexCoord3hvNV_ = new Delegates.MultiTexCoord3hvNV_(Imports.MultiTexCoord3hvNV_);
+        public static Delegates.MultiTexCoord4hNV MultiTexCoord4hNV = new Delegates.MultiTexCoord4hNV(Imports.MultiTexCoord4hNV);
+        public static Delegates.MultiTexCoord4hvNV_ MultiTexCoord4hvNV_ = new Delegates.MultiTexCoord4hvNV_(Imports.MultiTexCoord4hvNV_);
+        public static Delegates.FogCoordhNV FogCoordhNV = new Delegates.FogCoordhNV(Imports.FogCoordhNV);
+        public static Delegates.FogCoordhvNV_ FogCoordhvNV_ = new Delegates.FogCoordhvNV_(Imports.FogCoordhvNV_);
+        public static Delegates.SecondaryColor3hNV SecondaryColor3hNV = new Delegates.SecondaryColor3hNV(Imports.SecondaryColor3hNV);
+        public static Delegates.SecondaryColor3hvNV_ SecondaryColor3hvNV_ = new Delegates.SecondaryColor3hvNV_(Imports.SecondaryColor3hvNV_);
+        public static Delegates.VertexWeighthNV VertexWeighthNV = new Delegates.VertexWeighthNV(Imports.VertexWeighthNV);
+        public static Delegates.VertexWeighthvNV_ VertexWeighthvNV_ = new Delegates.VertexWeighthvNV_(Imports.VertexWeighthvNV_);
+        public static Delegates.VertexAttrib1hNV VertexAttrib1hNV = new Delegates.VertexAttrib1hNV(Imports.VertexAttrib1hNV);
+        public static Delegates.VertexAttrib1hvNV_ VertexAttrib1hvNV_ = new Delegates.VertexAttrib1hvNV_(Imports.VertexAttrib1hvNV_);
+        public static Delegates.VertexAttrib2hNV VertexAttrib2hNV = new Delegates.VertexAttrib2hNV(Imports.VertexAttrib2hNV);
+        public static Delegates.VertexAttrib2hvNV_ VertexAttrib2hvNV_ = new Delegates.VertexAttrib2hvNV_(Imports.VertexAttrib2hvNV_);
+        public static Delegates.VertexAttrib3hNV VertexAttrib3hNV = new Delegates.VertexAttrib3hNV(Imports.VertexAttrib3hNV);
+        public static Delegates.VertexAttrib3hvNV_ VertexAttrib3hvNV_ = new Delegates.VertexAttrib3hvNV_(Imports.VertexAttrib3hvNV_);
+        public static Delegates.VertexAttrib4hNV VertexAttrib4hNV = new Delegates.VertexAttrib4hNV(Imports.VertexAttrib4hNV);
+        public static Delegates.VertexAttrib4hvNV_ VertexAttrib4hvNV_ = new Delegates.VertexAttrib4hvNV_(Imports.VertexAttrib4hvNV_);
+        public static Delegates.VertexAttribs1hvNV_ VertexAttribs1hvNV_ = new Delegates.VertexAttribs1hvNV_(Imports.VertexAttribs1hvNV_);
+        public static Delegates.VertexAttribs2hvNV_ VertexAttribs2hvNV_ = new Delegates.VertexAttribs2hvNV_(Imports.VertexAttribs2hvNV_);
+        public static Delegates.VertexAttribs3hvNV_ VertexAttribs3hvNV_ = new Delegates.VertexAttribs3hvNV_(Imports.VertexAttribs3hvNV_);
+        public static Delegates.VertexAttribs4hvNV_ VertexAttribs4hvNV_ = new Delegates.VertexAttribs4hvNV_(Imports.VertexAttribs4hvNV_);
+        public static Delegates.PixelDataRangeNV_ PixelDataRangeNV_ = new Delegates.PixelDataRangeNV_(Imports.PixelDataRangeNV_);
+        public static Delegates.FlushPixelDataRangeNV FlushPixelDataRangeNV = new Delegates.FlushPixelDataRangeNV(Imports.FlushPixelDataRangeNV);
+        public static Delegates.PrimitiveRestartNV PrimitiveRestartNV = new Delegates.PrimitiveRestartNV(Imports.PrimitiveRestartNV);
+        public static Delegates.PrimitiveRestartIndexNV PrimitiveRestartIndexNV = new Delegates.PrimitiveRestartIndexNV(Imports.PrimitiveRestartIndexNV);
+        public static Delegates.MapObjectBufferATI MapObjectBufferATI = new Delegates.MapObjectBufferATI(Imports.MapObjectBufferATI);
+        public static Delegates.UnmapObjectBufferATI UnmapObjectBufferATI = new Delegates.UnmapObjectBufferATI(Imports.UnmapObjectBufferATI);
+        public static Delegates.StencilOpSeparateATI StencilOpSeparateATI = new Delegates.StencilOpSeparateATI(Imports.StencilOpSeparateATI);
+        public static Delegates.StencilFuncSeparateATI StencilFuncSeparateATI = new Delegates.StencilFuncSeparateATI(Imports.StencilFuncSeparateATI);
+        public static Delegates.VertexAttribArrayObjectATI VertexAttribArrayObjectATI = new Delegates.VertexAttribArrayObjectATI(Imports.VertexAttribArrayObjectATI);
+        public static Delegates.GetVertexAttribArrayObjectfvATI_ GetVertexAttribArrayObjectfvATI_ = new Delegates.GetVertexAttribArrayObjectfvATI_(Imports.GetVertexAttribArrayObjectfvATI_);
+        public static Delegates.GetVertexAttribArrayObjectivATI_ GetVertexAttribArrayObjectivATI_ = new Delegates.GetVertexAttribArrayObjectivATI_(Imports.GetVertexAttribArrayObjectivATI_);
+        public static Delegates.DepthBoundsEXT DepthBoundsEXT = new Delegates.DepthBoundsEXT(Imports.DepthBoundsEXT);
+        public static Delegates.BlendEquationSeparateEXT BlendEquationSeparateEXT = new Delegates.BlendEquationSeparateEXT(Imports.BlendEquationSeparateEXT);
+        public static Delegates.IsRenderbufferEXT IsRenderbufferEXT = new Delegates.IsRenderbufferEXT(Imports.IsRenderbufferEXT);
+        public static Delegates.BindRenderbufferEXT BindRenderbufferEXT = new Delegates.BindRenderbufferEXT(Imports.BindRenderbufferEXT);
+        public static Delegates.DeleteRenderbuffersEXT_ DeleteRenderbuffersEXT_ = new Delegates.DeleteRenderbuffersEXT_(Imports.DeleteRenderbuffersEXT_);
+        public static Delegates.GenRenderbuffersEXT_ GenRenderbuffersEXT_ = new Delegates.GenRenderbuffersEXT_(Imports.GenRenderbuffersEXT_);
+        public static Delegates.RenderbufferStorageEXT RenderbufferStorageEXT = new Delegates.RenderbufferStorageEXT(Imports.RenderbufferStorageEXT);
+        public static Delegates.GetRenderbufferParameterivEXT_ GetRenderbufferParameterivEXT_ = new Delegates.GetRenderbufferParameterivEXT_(Imports.GetRenderbufferParameterivEXT_);
+        public static Delegates.IsFramebufferEXT IsFramebufferEXT = new Delegates.IsFramebufferEXT(Imports.IsFramebufferEXT);
+        public static Delegates.BindFramebufferEXT BindFramebufferEXT = new Delegates.BindFramebufferEXT(Imports.BindFramebufferEXT);
+        public static Delegates.DeleteFramebuffersEXT_ DeleteFramebuffersEXT_ = new Delegates.DeleteFramebuffersEXT_(Imports.DeleteFramebuffersEXT_);
+        public static Delegates.GenFramebuffersEXT_ GenFramebuffersEXT_ = new Delegates.GenFramebuffersEXT_(Imports.GenFramebuffersEXT_);
+        public static Delegates.CheckFramebufferStatusEXT CheckFramebufferStatusEXT = new Delegates.CheckFramebufferStatusEXT(Imports.CheckFramebufferStatusEXT);
+        public static Delegates.FramebufferTexture1DEXT FramebufferTexture1DEXT = new Delegates.FramebufferTexture1DEXT(Imports.FramebufferTexture1DEXT);
+        public static Delegates.FramebufferTexture2DEXT FramebufferTexture2DEXT = new Delegates.FramebufferTexture2DEXT(Imports.FramebufferTexture2DEXT);
+        public static Delegates.FramebufferTexture3DEXT FramebufferTexture3DEXT = new Delegates.FramebufferTexture3DEXT(Imports.FramebufferTexture3DEXT);
+        public static Delegates.FramebufferRenderbufferEXT FramebufferRenderbufferEXT = new Delegates.FramebufferRenderbufferEXT(Imports.FramebufferRenderbufferEXT);
+        public static Delegates.GetFramebufferAttachmentParameterivEXT_ GetFramebufferAttachmentParameterivEXT_ = new Delegates.GetFramebufferAttachmentParameterivEXT_(Imports.GetFramebufferAttachmentParameterivEXT_);
+        public static Delegates.GenerateMipmapEXT GenerateMipmapEXT = new Delegates.GenerateMipmapEXT(Imports.GenerateMipmapEXT);
+        public static Delegates.StringMarkerGREMEDY_ StringMarkerGREMEDY_ = new Delegates.StringMarkerGREMEDY_(Imports.StringMarkerGREMEDY_);
+        public static Delegates.StencilClearTagEXT StencilClearTagEXT = new Delegates.StencilClearTagEXT(Imports.StencilClearTagEXT);
+        public static Delegates.BlitFramebufferEXT BlitFramebufferEXT = new Delegates.BlitFramebufferEXT(Imports.BlitFramebufferEXT);
+        public static Delegates.RenderbufferStorageMultisampleEXT RenderbufferStorageMultisampleEXT = new Delegates.RenderbufferStorageMultisampleEXT(Imports.RenderbufferStorageMultisampleEXT);
+        public static Delegates.GetQueryObjecti64vEXT_ GetQueryObjecti64vEXT_ = new Delegates.GetQueryObjecti64vEXT_(Imports.GetQueryObjecti64vEXT_);
+        public static Delegates.GetQueryObjectui64vEXT_ GetQueryObjectui64vEXT_ = new Delegates.GetQueryObjectui64vEXT_(Imports.GetQueryObjectui64vEXT_);
+        public static Delegates.ProgramEnvParameters4fvEXT_ ProgramEnvParameters4fvEXT_ = new Delegates.ProgramEnvParameters4fvEXT_(Imports.ProgramEnvParameters4fvEXT_);
+        public static Delegates.ProgramLocalParameters4fvEXT_ ProgramLocalParameters4fvEXT_ = new Delegates.ProgramLocalParameters4fvEXT_(Imports.ProgramLocalParameters4fvEXT_);
+
+        #endregion
+
+        #region Wrappers
+
+        #region MultiTexCoord1dvARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord1dvARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord1dvARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord1dvARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord1dvARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1dvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1dvARB(GLenum target, GLdouble[] v)
+
+        public static
+        void MultiTexCoord1dvARB(GLenum target, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1dvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1fvARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord1fvARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord1fvARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord1fvARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord1fvARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1fvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1fvARB(GLenum target, GLfloat[] v)
+
+        public static
+        void MultiTexCoord1fvARB(GLenum target, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1fvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1ivARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord1ivARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord1ivARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord1ivARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord1ivARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1ivARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1ivARB(GLenum target, GLint[] v)
+
+        public static
+        void MultiTexCoord1ivARB(GLenum target, GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1ivARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1svARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord1svARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord1svARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord1svARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord1svARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1svARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1svARB(GLenum target, GLshort[] v)
+
+        public static
+        void MultiTexCoord1svARB(GLenum target, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1svARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2dvARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord2dvARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord2dvARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord2dvARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord2dvARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2dvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2dvARB(GLenum target, GLdouble[] v)
+
+        public static
+        void MultiTexCoord2dvARB(GLenum target, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2dvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2fvARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord2fvARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord2fvARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord2fvARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord2fvARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2fvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2fvARB(GLenum target, GLfloat[] v)
+
+        public static
+        void MultiTexCoord2fvARB(GLenum target, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2fvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2ivARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord2ivARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord2ivARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord2ivARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord2ivARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2ivARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2ivARB(GLenum target, GLint[] v)
+
+        public static
+        void MultiTexCoord2ivARB(GLenum target, GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2ivARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2svARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord2svARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord2svARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord2svARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord2svARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2svARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2svARB(GLenum target, GLshort[] v)
+
+        public static
+        void MultiTexCoord2svARB(GLenum target, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2svARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3dvARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord3dvARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord3dvARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord3dvARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord3dvARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3dvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3dvARB(GLenum target, GLdouble[] v)
+
+        public static
+        void MultiTexCoord3dvARB(GLenum target, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3dvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3fvARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord3fvARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord3fvARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord3fvARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord3fvARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3fvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3fvARB(GLenum target, GLfloat[] v)
+
+        public static
+        void MultiTexCoord3fvARB(GLenum target, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3fvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3ivARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord3ivARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord3ivARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord3ivARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord3ivARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3ivARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3ivARB(GLenum target, GLint[] v)
+
+        public static
+        void MultiTexCoord3ivARB(GLenum target, GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3ivARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3svARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord3svARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord3svARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord3svARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord3svARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3svARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3svARB(GLenum target, GLshort[] v)
+
+        public static
+        void MultiTexCoord3svARB(GLenum target, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3svARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4dvARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord4dvARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord4dvARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord4dvARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord4dvARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4dvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4dvARB(GLenum target, GLdouble[] v)
+
+        public static
+        void MultiTexCoord4dvARB(GLenum target, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4dvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4fvARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord4fvARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord4fvARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord4fvARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord4fvARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4fvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4fvARB(GLenum target, GLfloat[] v)
+
+        public static
+        void MultiTexCoord4fvARB(GLenum target, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4fvARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4ivARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord4ivARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord4ivARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord4ivARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord4ivARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4ivARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4ivARB(GLenum target, GLint[] v)
+
+        public static
+        void MultiTexCoord4ivARB(GLenum target, GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4ivARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4svARB(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord4svARB(GLenum target, IntPtr v)
+        {
+            MultiTexCoord4svARB_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord4svARB(GLenum target, object v)
+
+        public static
+        void MultiTexCoord4svARB(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4svARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4svARB(GLenum target, GLshort[] v)
+
+        public static
+        void MultiTexCoord4svARB(GLenum target, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4svARB_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region LoadTransposeMatrixfARB(IntPtr m)
+
+        public static
+        void LoadTransposeMatrixfARB(IntPtr m)
+        {
+            LoadTransposeMatrixfARB_(m);
+        }
+
+        #endregion
+
+        #region LoadTransposeMatrixfARB(object m)
+
+        public static
+        void LoadTransposeMatrixfARB(object m)
+        {
+            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+            try
+            {
+                LoadTransposeMatrixfARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region LoadTransposeMatrixfARB(GLfloat[] m)
+
+        public static
+        void LoadTransposeMatrixfARB(GLfloat[] m)
+        {
+            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+            try
+            {
+                LoadTransposeMatrixfARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region LoadTransposeMatrixdARB(IntPtr m)
+
+        public static
+        void LoadTransposeMatrixdARB(IntPtr m)
+        {
+            LoadTransposeMatrixdARB_(m);
+        }
+
+        #endregion
+
+        #region LoadTransposeMatrixdARB(object m)
+
+        public static
+        void LoadTransposeMatrixdARB(object m)
+        {
+            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+            try
+            {
+                LoadTransposeMatrixdARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region LoadTransposeMatrixdARB(GLdouble[] m)
+
+        public static
+        void LoadTransposeMatrixdARB(GLdouble[] m)
+        {
+            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+            try
+            {
+                LoadTransposeMatrixdARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultTransposeMatrixfARB(IntPtr m)
+
+        public static
+        void MultTransposeMatrixfARB(IntPtr m)
+        {
+            MultTransposeMatrixfARB_(m);
+        }
+
+        #endregion
+
+        #region MultTransposeMatrixfARB(object m)
+
+        public static
+        void MultTransposeMatrixfARB(object m)
+        {
+            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+            try
+            {
+                MultTransposeMatrixfARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultTransposeMatrixfARB(GLfloat[] m)
+
+        public static
+        void MultTransposeMatrixfARB(GLfloat[] m)
+        {
+            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+            try
+            {
+                MultTransposeMatrixfARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultTransposeMatrixdARB(IntPtr m)
+
+        public static
+        void MultTransposeMatrixdARB(IntPtr m)
+        {
+            MultTransposeMatrixdARB_(m);
+        }
+
+        #endregion
+
+        #region MultTransposeMatrixdARB(object m)
+
+        public static
+        void MultTransposeMatrixdARB(object m)
+        {
+            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+            try
+            {
+                MultTransposeMatrixdARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultTransposeMatrixdARB(GLdouble[] m)
+
+        public static
+        void MultTransposeMatrixdARB(GLdouble[] m)
+        {
+            GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+            try
+            {
+                MultTransposeMatrixdARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data)
+
+        public static
+        void CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data)
+        {
+            CompressedTexImage3DARB_(target, level, internalformat, width, height, depth, border, imageSize, data);
+        }
+
+        #endregion
+
+        #region CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
+
+        public static
+        void CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                CompressedTexImage3DARB_(target, level, internalformat, width, height, depth, border, imageSize, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data)
+
+        public static
+        void CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data)
+        {
+            CompressedTexImage2DARB_(target, level, internalformat, width, height, border, imageSize, data);
+        }
+
+        #endregion
+
+        #region CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
+
+        public static
+        void CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                CompressedTexImage2DARB_(target, level, internalformat, width, height, border, imageSize, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data)
+
+        public static
+        void CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data)
+        {
+            CompressedTexImage1DARB_(target, level, internalformat, width, border, imageSize, data);
+        }
+
+        #endregion
+
+        #region CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
+
+        public static
+        void CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                CompressedTexImage1DARB_(target, level, internalformat, width, border, imageSize, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
+
+        public static
+        void CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
+        {
+            CompressedTexSubImage3DARB_(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+        }
+
+        #endregion
+
+        #region CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, object data)
+
+        public static
+        void CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                CompressedTexSubImage3DARB_(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
+
+        public static
+        void CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
+        {
+            CompressedTexSubImage2DARB_(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+        }
+
+        #endregion
+
+        #region CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, object data)
+
+        public static
+        void CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                CompressedTexSubImage2DARB_(target, level, xoffset, yoffset, width, height, format, imageSize, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
+
+        public static
+        void CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data)
+        {
+            CompressedTexSubImage1DARB_(target, level, xoffset, width, format, imageSize, data);
+        }
+
+        #endregion
+
+        #region CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, object data)
+
+        public static
+        void CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                CompressedTexSubImage1DARB_(target, level, xoffset, width, format, imageSize, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, IntPtr img)
+
+        public static
+        void GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, IntPtr img)
+        {
+            GetCompressedTexImageARB_(target, level, img);
+        }
+
+        #endregion
+
+        #region GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, object img)
+
+        public static
+        void GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, object img)
+        {
+            GCHandle h0 = GCHandle.Alloc(img, GCHandleType.Pinned);
+            try
+            {
+                GetCompressedTexImageARB_(target, level, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PointParameterfvARB(GLenum pname, IntPtr parameters)
+
+        public static
+        void PointParameterfvARB(GLenum pname, IntPtr parameters)
+        {
+            PointParameterfvARB_(pname, parameters);
+        }
+
+        #endregion
+
+        #region PointParameterfvARB(GLenum pname, object parameters)
+
+        public static
+        void PointParameterfvARB(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PointParameterfvARB_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PointParameterfvARB(GLenum pname, GLfloat[] parameters)
+
+        public static
+        void PointParameterfvARB(GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PointParameterfvARB_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightbvARB(GLint size, IntPtr weights)
+
+        public static
+        void WeightbvARB(GLint size, IntPtr weights)
+        {
+            WeightbvARB_(size, weights);
+        }
+
+        #endregion
+
+        #region WeightbvARB(GLint size, object weights)
+
+        public static
+        void WeightbvARB(GLint size, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightbvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightbvARB(GLint size, GLbyte[] weights)
+
+        public static
+        void WeightbvARB(GLint size, GLbyte[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightbvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightsvARB(GLint size, IntPtr weights)
+
+        public static
+        void WeightsvARB(GLint size, IntPtr weights)
+        {
+            WeightsvARB_(size, weights);
+        }
+
+        #endregion
+
+        #region WeightsvARB(GLint size, object weights)
+
+        public static
+        void WeightsvARB(GLint size, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightsvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightsvARB(GLint size, GLshort[] weights)
+
+        public static
+        void WeightsvARB(GLint size, GLshort[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightsvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightivARB(GLint size, IntPtr weights)
+
+        public static
+        void WeightivARB(GLint size, IntPtr weights)
+        {
+            WeightivARB_(size, weights);
+        }
+
+        #endregion
+
+        #region WeightivARB(GLint size, object weights)
+
+        public static
+        void WeightivARB(GLint size, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightivARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightivARB(GLint size, GLint[] weights)
+
+        public static
+        void WeightivARB(GLint size, GLint[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightivARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightfvARB(GLint size, IntPtr weights)
+
+        public static
+        void WeightfvARB(GLint size, IntPtr weights)
+        {
+            WeightfvARB_(size, weights);
+        }
+
+        #endregion
+
+        #region WeightfvARB(GLint size, object weights)
+
+        public static
+        void WeightfvARB(GLint size, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightfvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightfvARB(GLint size, GLfloat[] weights)
+
+        public static
+        void WeightfvARB(GLint size, GLfloat[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightfvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightdvARB(GLint size, IntPtr weights)
+
+        public static
+        void WeightdvARB(GLint size, IntPtr weights)
+        {
+            WeightdvARB_(size, weights);
+        }
+
+        #endregion
+
+        #region WeightdvARB(GLint size, object weights)
+
+        public static
+        void WeightdvARB(GLint size, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightdvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightdvARB(GLint size, GLdouble[] weights)
+
+        public static
+        void WeightdvARB(GLint size, GLdouble[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightdvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightubvARB(GLint size, IntPtr weights)
+
+        public static
+        void WeightubvARB(GLint size, IntPtr weights)
+        {
+            WeightubvARB_(size, weights);
+        }
+
+        #endregion
+
+        #region WeightubvARB(GLint size, object weights)
+
+        public static
+        void WeightubvARB(GLint size, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightubvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightubvARB(GLint size, GLubyte[] weights)
+
+        public static
+        void WeightubvARB(GLint size, GLubyte[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightubvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightusvARB(GLint size, IntPtr weights)
+
+        public static
+        void WeightusvARB(GLint size, IntPtr weights)
+        {
+            WeightusvARB_(size, weights);
+        }
+
+        #endregion
+
+        #region WeightusvARB(GLint size, object weights)
+
+        public static
+        void WeightusvARB(GLint size, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightusvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightusvARB(GLint size, GLushort[] weights)
+
+        public static
+        void WeightusvARB(GLint size, GLushort[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightusvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightuivARB(GLint size, IntPtr weights)
+
+        public static
+        void WeightuivARB(GLint size, IntPtr weights)
+        {
+            WeightuivARB_(size, weights);
+        }
+
+        #endregion
+
+        #region WeightuivARB(GLint size, object weights)
+
+        public static
+        void WeightuivARB(GLint size, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightuivARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightuivARB(GLint size, GLuint[] weights)
+
+        public static
+        void WeightuivARB(GLint size, GLuint[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                WeightuivARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WeightPointerARB(GLint size, GLenum type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void WeightPointerARB(GLint size, GLenum type, GLsizei stride, IntPtr pointer)
+        {
+            WeightPointerARB_(size, type, stride, pointer);
+        }
+
+        #endregion
+
+        #region WeightPointerARB(GLint size, GLenum type, GLsizei stride, object pointer)
+
+        public static
+        void WeightPointerARB(GLint size, GLenum type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                WeightPointerARB_(size, type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MatrixIndexubvARB(GLint size, IntPtr indices)
+
+        public static
+        void MatrixIndexubvARB(GLint size, IntPtr indices)
+        {
+            MatrixIndexubvARB_(size, indices);
+        }
+
+        #endregion
+
+        #region MatrixIndexubvARB(GLint size, object indices)
+
+        public static
+        void MatrixIndexubvARB(GLint size, object indices)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MatrixIndexubvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MatrixIndexubvARB(GLint size, GLubyte[] indices)
+
+        public static
+        void MatrixIndexubvARB(GLint size, GLubyte[] indices)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MatrixIndexubvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MatrixIndexusvARB(GLint size, IntPtr indices)
+
+        public static
+        void MatrixIndexusvARB(GLint size, IntPtr indices)
+        {
+            MatrixIndexusvARB_(size, indices);
+        }
+
+        #endregion
+
+        #region MatrixIndexusvARB(GLint size, object indices)
+
+        public static
+        void MatrixIndexusvARB(GLint size, object indices)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MatrixIndexusvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MatrixIndexusvARB(GLint size, GLushort[] indices)
+
+        public static
+        void MatrixIndexusvARB(GLint size, GLushort[] indices)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MatrixIndexusvARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MatrixIndexuivARB(GLint size, IntPtr indices)
+
+        public static
+        void MatrixIndexuivARB(GLint size, IntPtr indices)
+        {
+            MatrixIndexuivARB_(size, indices);
+        }
+
+        #endregion
+
+        #region MatrixIndexuivARB(GLint size, object indices)
+
+        public static
+        void MatrixIndexuivARB(GLint size, object indices)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MatrixIndexuivARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MatrixIndexuivARB(GLint size, GLuint[] indices)
+
+        public static
+        void MatrixIndexuivARB(GLint size, GLuint[] indices)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MatrixIndexuivARB_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void MatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, IntPtr pointer)
+        {
+            MatrixIndexPointerARB_(size, type, stride, pointer);
+        }
+
+        #endregion
+
+        #region MatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, object pointer)
+
+        public static
+        void MatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                MatrixIndexPointerARB_(size, type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2dvARB(IntPtr v)
+
+        public static
+        void WindowPos2dvARB(IntPtr v)
+        {
+            WindowPos2dvARB_(v);
+        }
+
+        #endregion
+
+        #region WindowPos2dvARB(object v)
+
+        public static
+        void WindowPos2dvARB(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2dvARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2dvARB(GLdouble[] v)
+
+        public static
+        void WindowPos2dvARB(GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2dvARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2fvARB(IntPtr v)
+
+        public static
+        void WindowPos2fvARB(IntPtr v)
+        {
+            WindowPos2fvARB_(v);
+        }
+
+        #endregion
+
+        #region WindowPos2fvARB(object v)
+
+        public static
+        void WindowPos2fvARB(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2fvARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2fvARB(GLfloat[] v)
+
+        public static
+        void WindowPos2fvARB(GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2fvARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2ivARB(IntPtr v)
+
+        public static
+        void WindowPos2ivARB(IntPtr v)
+        {
+            WindowPos2ivARB_(v);
+        }
+
+        #endregion
+
+        #region WindowPos2ivARB(object v)
+
+        public static
+        void WindowPos2ivARB(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2ivARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2ivARB(GLint[] v)
+
+        public static
+        void WindowPos2ivARB(GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2ivARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2svARB(IntPtr v)
+
+        public static
+        void WindowPos2svARB(IntPtr v)
+        {
+            WindowPos2svARB_(v);
+        }
+
+        #endregion
+
+        #region WindowPos2svARB(object v)
+
+        public static
+        void WindowPos2svARB(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2svARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2svARB(GLshort[] v)
+
+        public static
+        void WindowPos2svARB(GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2svARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3dvARB(IntPtr v)
+
+        public static
+        void WindowPos3dvARB(IntPtr v)
+        {
+            WindowPos3dvARB_(v);
+        }
+
+        #endregion
+
+        #region WindowPos3dvARB(object v)
+
+        public static
+        void WindowPos3dvARB(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3dvARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3dvARB(GLdouble[] v)
+
+        public static
+        void WindowPos3dvARB(GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3dvARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3fvARB(IntPtr v)
+
+        public static
+        void WindowPos3fvARB(IntPtr v)
+        {
+            WindowPos3fvARB_(v);
+        }
+
+        #endregion
+
+        #region WindowPos3fvARB(object v)
+
+        public static
+        void WindowPos3fvARB(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3fvARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3fvARB(GLfloat[] v)
+
+        public static
+        void WindowPos3fvARB(GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3fvARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3ivARB(IntPtr v)
+
+        public static
+        void WindowPos3ivARB(IntPtr v)
+        {
+            WindowPos3ivARB_(v);
+        }
+
+        #endregion
+
+        #region WindowPos3ivARB(object v)
+
+        public static
+        void WindowPos3ivARB(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3ivARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3ivARB(GLint[] v)
+
+        public static
+        void WindowPos3ivARB(GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3ivARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3svARB(IntPtr v)
+
+        public static
+        void WindowPos3svARB(IntPtr v)
+        {
+            WindowPos3svARB_(v);
+        }
+
+        #endregion
+
+        #region WindowPos3svARB(object v)
+
+        public static
+        void WindowPos3svARB(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3svARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3svARB(GLshort[] v)
+
+        public static
+        void WindowPos3svARB(GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3svARB_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1dvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib1dvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib1dvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib1dvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib1dvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1dvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1dvARB(GLuint index, GLdouble[] v)
+
+        public static
+        void VertexAttrib1dvARB(GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1dvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1fvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib1fvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib1fvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib1fvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib1fvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1fvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1fvARB(GLuint index, GLfloat[] v)
+
+        public static
+        void VertexAttrib1fvARB(GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1fvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1svARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib1svARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib1svARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib1svARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib1svARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1svARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1svARB(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib1svARB(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1svARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2dvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib2dvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib2dvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib2dvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib2dvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2dvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2dvARB(GLuint index, GLdouble[] v)
+
+        public static
+        void VertexAttrib2dvARB(GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2dvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2fvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib2fvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib2fvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib2fvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib2fvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2fvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2fvARB(GLuint index, GLfloat[] v)
+
+        public static
+        void VertexAttrib2fvARB(GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2fvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2svARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib2svARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib2svARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib2svARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib2svARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2svARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2svARB(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib2svARB(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2svARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3dvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib3dvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib3dvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib3dvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib3dvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3dvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3dvARB(GLuint index, GLdouble[] v)
+
+        public static
+        void VertexAttrib3dvARB(GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3dvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3fvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib3fvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib3fvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib3fvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib3fvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3fvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3fvARB(GLuint index, GLfloat[] v)
+
+        public static
+        void VertexAttrib3fvARB(GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3fvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3svARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib3svARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib3svARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib3svARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib3svARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3svARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3svARB(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib3svARB(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3svARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NbvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4NbvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4NbvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4NbvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4NbvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NbvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NbvARB(GLuint index, GLbyte[] v)
+
+        public static
+        void VertexAttrib4NbvARB(GLuint index, GLbyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NbvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NivARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4NivARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4NivARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4NivARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4NivARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NivARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NivARB(GLuint index, GLint[] v)
+
+        public static
+        void VertexAttrib4NivARB(GLuint index, GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NivARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NsvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4NsvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4NsvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4NsvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4NsvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NsvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NsvARB(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib4NsvARB(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NsvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NubvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4NubvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4NubvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4NubvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4NubvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NubvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NubvARB(GLuint index, GLubyte[] v)
+
+        public static
+        void VertexAttrib4NubvARB(GLuint index, GLubyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NubvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NuivARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4NuivARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4NuivARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4NuivARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4NuivARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NuivARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NuivARB(GLuint index, GLuint[] v)
+
+        public static
+        void VertexAttrib4NuivARB(GLuint index, GLuint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NuivARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NusvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4NusvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4NusvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4NusvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4NusvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NusvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4NusvARB(GLuint index, GLushort[] v)
+
+        public static
+        void VertexAttrib4NusvARB(GLuint index, GLushort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4NusvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4bvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4bvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4bvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4bvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4bvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4bvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4bvARB(GLuint index, GLbyte[] v)
+
+        public static
+        void VertexAttrib4bvARB(GLuint index, GLbyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4bvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4dvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4dvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4dvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4dvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4dvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4dvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4dvARB(GLuint index, GLdouble[] v)
+
+        public static
+        void VertexAttrib4dvARB(GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4dvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4fvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4fvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4fvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4fvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4fvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4fvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4fvARB(GLuint index, GLfloat[] v)
+
+        public static
+        void VertexAttrib4fvARB(GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4fvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4ivARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4ivARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4ivARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4ivARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4ivARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4ivARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4ivARB(GLuint index, GLint[] v)
+
+        public static
+        void VertexAttrib4ivARB(GLuint index, GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4ivARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4svARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4svARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4svARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4svARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4svARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4svARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4svARB(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib4svARB(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4svARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4ubvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4ubvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4ubvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4ubvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4ubvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4ubvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4ubvARB(GLuint index, GLubyte[] v)
+
+        public static
+        void VertexAttrib4ubvARB(GLuint index, GLubyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4ubvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4uivARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4uivARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4uivARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4uivARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4uivARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4uivARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4uivARB(GLuint index, GLuint[] v)
+
+        public static
+        void VertexAttrib4uivARB(GLuint index, GLuint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4uivARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4usvARB(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4usvARB(GLuint index, IntPtr v)
+        {
+            VertexAttrib4usvARB_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4usvARB(GLuint index, object v)
+
+        public static
+        void VertexAttrib4usvARB(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4usvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4usvARB(GLuint index, GLushort[] v)
+
+        public static
+        void VertexAttrib4usvARB(GLuint index, GLushort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4usvARB_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribPointerARB(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer)
+
+        public static
+        void VertexAttribPointerARB(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer)
+        {
+            VertexAttribPointerARB_(index, size, type, normalized, stride, pointer);
+        }
+
+        #endregion
+
+        #region VertexAttribPointerARB(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, object pointer)
+
+        public static
+        void VertexAttribPointerARB(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribPointerARB_(index, size, type, normalized, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramStringARB(GLenum target, GLenum format, GLsizei len, IntPtr @string)
+
+        public static
+        void ProgramStringARB(GLenum target, GLenum format, GLsizei len, IntPtr @string)
+        {
+            ProgramStringARB_(target, format, len, @string);
+        }
+
+        #endregion
+
+        #region ProgramStringARB(GLenum target, GLenum format, GLsizei len, object @string)
+
+        public static
+        void ProgramStringARB(GLenum target, GLenum format, GLsizei len, object @string)
+        {
+            GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
+            try
+            {
+                ProgramStringARB_(target, format, len, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteProgramsARB(GLsizei n, IntPtr programs)
+
+        public static
+        void DeleteProgramsARB(GLsizei n, IntPtr programs)
+        {
+            DeleteProgramsARB_(n, programs);
+        }
+
+        #endregion
+
+        #region DeleteProgramsARB(GLsizei n, object programs)
+
+        public static
+        void DeleteProgramsARB(GLsizei n, object programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                DeleteProgramsARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteProgramsARB(GLsizei n, GLuint[] programs)
+
+        public static
+        void DeleteProgramsARB(GLsizei n, GLuint[] programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                DeleteProgramsARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenProgramsARB(GLsizei n, IntPtr programs)
+
+        public static
+        void GenProgramsARB(GLsizei n, IntPtr programs)
+        {
+            GenProgramsARB_(n, programs);
+        }
+
+        #endregion
+
+        #region GenProgramsARB(GLsizei n, object programs)
+
+        public static
+        void GenProgramsARB(GLsizei n, object programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                GenProgramsARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenProgramsARB(GLsizei n, GLuint[] programs)
+
+        public static
+        void GenProgramsARB(GLsizei n, GLuint[] programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                GenProgramsARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramEnvParameter4dvARB(GLenum target, GLuint index, IntPtr parameters)
+
+        public static
+        void ProgramEnvParameter4dvARB(GLenum target, GLuint index, IntPtr parameters)
+        {
+            ProgramEnvParameter4dvARB_(target, index, parameters);
+        }
+
+        #endregion
+
+        #region ProgramEnvParameter4dvARB(GLenum target, GLuint index, object parameters)
+
+        public static
+        void ProgramEnvParameter4dvARB(GLenum target, GLuint index, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramEnvParameter4dvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramEnvParameter4dvARB(GLenum target, GLuint index, GLdouble[] parameters)
+
+        public static
+        void ProgramEnvParameter4dvARB(GLenum target, GLuint index, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramEnvParameter4dvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramEnvParameter4fvARB(GLenum target, GLuint index, IntPtr parameters)
+
+        public static
+        void ProgramEnvParameter4fvARB(GLenum target, GLuint index, IntPtr parameters)
+        {
+            ProgramEnvParameter4fvARB_(target, index, parameters);
+        }
+
+        #endregion
+
+        #region ProgramEnvParameter4fvARB(GLenum target, GLuint index, object parameters)
+
+        public static
+        void ProgramEnvParameter4fvARB(GLenum target, GLuint index, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramEnvParameter4fvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramEnvParameter4fvARB(GLenum target, GLuint index, GLfloat[] parameters)
+
+        public static
+        void ProgramEnvParameter4fvARB(GLenum target, GLuint index, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramEnvParameter4fvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramLocalParameter4dvARB(GLenum target, GLuint index, IntPtr parameters)
+
+        public static
+        void ProgramLocalParameter4dvARB(GLenum target, GLuint index, IntPtr parameters)
+        {
+            ProgramLocalParameter4dvARB_(target, index, parameters);
+        }
+
+        #endregion
+
+        #region ProgramLocalParameter4dvARB(GLenum target, GLuint index, object parameters)
+
+        public static
+        void ProgramLocalParameter4dvARB(GLenum target, GLuint index, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramLocalParameter4dvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramLocalParameter4dvARB(GLenum target, GLuint index, GLdouble[] parameters)
+
+        public static
+        void ProgramLocalParameter4dvARB(GLenum target, GLuint index, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramLocalParameter4dvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramLocalParameter4fvARB(GLenum target, GLuint index, IntPtr parameters)
+
+        public static
+        void ProgramLocalParameter4fvARB(GLenum target, GLuint index, IntPtr parameters)
+        {
+            ProgramLocalParameter4fvARB_(target, index, parameters);
+        }
+
+        #endregion
+
+        #region ProgramLocalParameter4fvARB(GLenum target, GLuint index, object parameters)
+
+        public static
+        void ProgramLocalParameter4fvARB(GLenum target, GLuint index, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramLocalParameter4fvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramLocalParameter4fvARB(GLenum target, GLuint index, GLfloat[] parameters)
+
+        public static
+        void ProgramLocalParameter4fvARB(GLenum target, GLuint index, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramLocalParameter4fvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramEnvParameterdvARB(GLenum target, GLuint index, IntPtr parameters)
+
+        public static
+        void GetProgramEnvParameterdvARB(GLenum target, GLuint index, IntPtr parameters)
+        {
+            GetProgramEnvParameterdvARB_(target, index, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramEnvParameterdvARB(GLenum target, GLuint index, object parameters)
+
+        public static
+        void GetProgramEnvParameterdvARB(GLenum target, GLuint index, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramEnvParameterdvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble[] parameters)
+
+        public static
+        void GetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramEnvParameterdvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramEnvParameterfvARB(GLenum target, GLuint index, IntPtr parameters)
+
+        public static
+        void GetProgramEnvParameterfvARB(GLenum target, GLuint index, IntPtr parameters)
+        {
+            GetProgramEnvParameterfvARB_(target, index, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramEnvParameterfvARB(GLenum target, GLuint index, object parameters)
+
+        public static
+        void GetProgramEnvParameterfvARB(GLenum target, GLuint index, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramEnvParameterfvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat[] parameters)
+
+        public static
+        void GetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramEnvParameterfvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramLocalParameterdvARB(GLenum target, GLuint index, IntPtr parameters)
+
+        public static
+        void GetProgramLocalParameterdvARB(GLenum target, GLuint index, IntPtr parameters)
+        {
+            GetProgramLocalParameterdvARB_(target, index, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramLocalParameterdvARB(GLenum target, GLuint index, object parameters)
+
+        public static
+        void GetProgramLocalParameterdvARB(GLenum target, GLuint index, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramLocalParameterdvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble[] parameters)
+
+        public static
+        void GetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramLocalParameterdvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramLocalParameterfvARB(GLenum target, GLuint index, IntPtr parameters)
+
+        public static
+        void GetProgramLocalParameterfvARB(GLenum target, GLuint index, IntPtr parameters)
+        {
+            GetProgramLocalParameterfvARB_(target, index, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramLocalParameterfvARB(GLenum target, GLuint index, object parameters)
+
+        public static
+        void GetProgramLocalParameterfvARB(GLenum target, GLuint index, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramLocalParameterfvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat[] parameters)
+
+        public static
+        void GetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramLocalParameterfvARB_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramivARB(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetProgramivARB(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetProgramivARB_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramivARB(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetProgramivARB(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramivARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramivARB(GLenum target, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetProgramivARB(GLenum target, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramivARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramStringARB(GLenum target, GLenum pname, IntPtr @string)
+
+        public static
+        void GetProgramStringARB(GLenum target, GLenum pname, IntPtr @string)
+        {
+            GetProgramStringARB_(target, pname, @string);
+        }
+
+        #endregion
+
+        #region GetProgramStringARB(GLenum target, GLenum pname, object @string)
+
+        public static
+        void GetProgramStringARB(GLenum target, GLenum pname, object @string)
+        {
+            GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
+            try
+            {
+                GetProgramStringARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribdvARB(GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVertexAttribdvARB(GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetVertexAttribdvARB_(index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVertexAttribdvARB(GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetVertexAttribdvARB(GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribdvARB_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble[] parameters)
+
+        public static
+        void GetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribdvARB_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribfvARB(GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVertexAttribfvARB(GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetVertexAttribfvARB_(index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVertexAttribfvARB(GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetVertexAttribfvARB(GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribfvARB_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribfvARB_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribivARB(GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVertexAttribivARB(GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetVertexAttribivARB_(index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVertexAttribivARB(GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetVertexAttribivARB(GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribivARB_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribivARB(GLuint index, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetVertexAttribivARB(GLuint index, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribivARB_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribPointervARB(GLuint index, GLenum pname, IntPtr pointer)
+
+        public static
+        void GetVertexAttribPointervARB(GLuint index, GLenum pname, IntPtr pointer)
+        {
+            GetVertexAttribPointervARB_(index, pname, pointer);
+        }
+
+        #endregion
+
+        #region GetVertexAttribPointervARB(GLuint index, GLenum pname, object pointer)
+
+        public static
+        void GetVertexAttribPointervARB(GLuint index, GLenum pname, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribPointervARB_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribPointervARB(GLuint index, GLenum pname, IntPtr[] pointer)
+
+        public static
+        void GetVertexAttribPointervARB(GLuint index, GLenum pname, IntPtr[] pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribPointervARB_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteBuffersARB(GLsizei n, IntPtr buffers)
+
+        public static
+        void DeleteBuffersARB(GLsizei n, IntPtr buffers)
+        {
+            DeleteBuffersARB_(n, buffers);
+        }
+
+        #endregion
+
+        #region DeleteBuffersARB(GLsizei n, object buffers)
+
+        public static
+        void DeleteBuffersARB(GLsizei n, object buffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+            try
+            {
+                DeleteBuffersARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteBuffersARB(GLsizei n, GLuint[] buffers)
+
+        public static
+        void DeleteBuffersARB(GLsizei n, GLuint[] buffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+            try
+            {
+                DeleteBuffersARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenBuffersARB(GLsizei n, IntPtr buffers)
+
+        public static
+        void GenBuffersARB(GLsizei n, IntPtr buffers)
+        {
+            GenBuffersARB_(n, buffers);
+        }
+
+        #endregion
+
+        #region GenBuffersARB(GLsizei n, object buffers)
+
+        public static
+        void GenBuffersARB(GLsizei n, object buffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+            try
+            {
+                GenBuffersARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenBuffersARB(GLsizei n, GLuint[] buffers)
+
+        public static
+        void GenBuffersARB(GLsizei n, GLuint[] buffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+            try
+            {
+                GenBuffersARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region BufferDataARB(GLenum target, GLsizeiptrARB size, IntPtr data, GLenum usage)
+
+        public static
+        void BufferDataARB(GLenum target, GLsizeiptrARB size, IntPtr data, GLenum usage)
+        {
+            BufferDataARB_(target, size, data, usage);
+        }
+
+        #endregion
+
+        #region BufferDataARB(GLenum target, GLsizeiptrARB size, object data, GLenum usage)
+
+        public static
+        void BufferDataARB(GLenum target, GLsizeiptrARB size, object data, GLenum usage)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                BufferDataARB_(target, size, h0.AddrOfPinnedObject(), usage);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data)
+
+        public static
+        void BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data)
+        {
+            BufferSubDataARB_(target, offset, size, data);
+        }
+
+        #endregion
+
+        #region BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, object data)
+
+        public static
+        void BufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                BufferSubDataARB_(target, offset, size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data)
+
+        public static
+        void GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data)
+        {
+            GetBufferSubDataARB_(target, offset, size, data);
+        }
+
+        #endregion
+
+        #region GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, object data)
+
+        public static
+        void GetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetBufferSubDataARB_(target, offset, size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetBufferParameterivARB(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetBufferParameterivARB(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetBufferParameterivARB_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetBufferParameterivARB(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetBufferParameterivARB(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetBufferParameterivARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetBufferParameterivARB(GLenum target, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetBufferParameterivARB(GLenum target, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetBufferParameterivARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetBufferPointervARB(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetBufferPointervARB(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetBufferPointervARB_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetBufferPointervARB(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetBufferPointervARB(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetBufferPointervARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetBufferPointervARB(GLenum target, GLenum pname, IntPtr[] parameters)
+
+        public static
+        void GetBufferPointervARB(GLenum target, GLenum pname, IntPtr[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetBufferPointervARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenQueriesARB(GLsizei n, IntPtr ids)
+
+        public static
+        void GenQueriesARB(GLsizei n, IntPtr ids)
+        {
+            GenQueriesARB_(n, ids);
+        }
+
+        #endregion
+
+        #region GenQueriesARB(GLsizei n, object ids)
+
+        public static
+        void GenQueriesARB(GLsizei n, object ids)
+        {
+            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+            try
+            {
+                GenQueriesARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenQueriesARB(GLsizei n, GLuint[] ids)
+
+        public static
+        void GenQueriesARB(GLsizei n, GLuint[] ids)
+        {
+            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+            try
+            {
+                GenQueriesARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteQueriesARB(GLsizei n, IntPtr ids)
+
+        public static
+        void DeleteQueriesARB(GLsizei n, IntPtr ids)
+        {
+            DeleteQueriesARB_(n, ids);
+        }
+
+        #endregion
+
+        #region DeleteQueriesARB(GLsizei n, object ids)
+
+        public static
+        void DeleteQueriesARB(GLsizei n, object ids)
+        {
+            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+            try
+            {
+                DeleteQueriesARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteQueriesARB(GLsizei n, GLuint[] ids)
+
+        public static
+        void DeleteQueriesARB(GLsizei n, GLuint[] ids)
+        {
+            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+            try
+            {
+                DeleteQueriesARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, IntPtr parameters)
+
+        public static
+        void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, IntPtr parameters)
+        {
+            GetQueryivARB_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, object parameters)
+
+        public static
+        void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryivARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, GLint[] parameters)
+
+        public static
+        void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryivARB_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters)
+
+        public static
+        void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters)
+        {
+            GetQueryObjectivARB_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, object parameters)
+
+        public static
+        void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryObjectivARB_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, GLint[] parameters)
+
+        public static
+        void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryObjectivARB_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters)
+
+        public static
+        void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, IntPtr parameters)
+        {
+            GetQueryObjectuivARB_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, object parameters)
+
+        public static
+        void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryObjectuivARB_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, GLuint[] parameters)
+
+        public static
+        void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, GLuint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryObjectuivARB_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, IntPtr length)
+
+        public static
+        void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, IntPtr length)
+        {
+            ShaderSourceARB_(shaderObj, count, @string, length);
+        }
+
+        #endregion
+
+        #region ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, object length)
+
+        public static
+        void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, object length)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                ShaderSourceARB_(shaderObj, count, @string, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, GLint[] length)
+
+        public static
+        void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string @string, GLint[] length)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                ShaderSourceARB_(shaderObj, count, @string, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform1fvARB(GLint location, GLsizei count, IntPtr value)
+
+        public static
+        void Uniform1fvARB(GLint location, GLsizei count, IntPtr value)
+        {
+            Uniform1fvARB_(location, count, value);
+        }
+
+        #endregion
+
+        #region Uniform1fvARB(GLint location, GLsizei count, object value)
+
+        public static
+        void Uniform1fvARB(GLint location, GLsizei count, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform1fvARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform1fvARB(GLint location, GLsizei count, GLfloat[] value)
+
+        public static
+        void Uniform1fvARB(GLint location, GLsizei count, GLfloat[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform1fvARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform2fvARB(GLint location, GLsizei count, IntPtr value)
+
+        public static
+        void Uniform2fvARB(GLint location, GLsizei count, IntPtr value)
+        {
+            Uniform2fvARB_(location, count, value);
+        }
+
+        #endregion
+
+        #region Uniform2fvARB(GLint location, GLsizei count, object value)
+
+        public static
+        void Uniform2fvARB(GLint location, GLsizei count, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform2fvARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform2fvARB(GLint location, GLsizei count, GLfloat[] value)
+
+        public static
+        void Uniform2fvARB(GLint location, GLsizei count, GLfloat[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform2fvARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform3fvARB(GLint location, GLsizei count, IntPtr value)
+
+        public static
+        void Uniform3fvARB(GLint location, GLsizei count, IntPtr value)
+        {
+            Uniform3fvARB_(location, count, value);
+        }
+
+        #endregion
+
+        #region Uniform3fvARB(GLint location, GLsizei count, object value)
+
+        public static
+        void Uniform3fvARB(GLint location, GLsizei count, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform3fvARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform3fvARB(GLint location, GLsizei count, GLfloat[] value)
+
+        public static
+        void Uniform3fvARB(GLint location, GLsizei count, GLfloat[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform3fvARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform4fvARB(GLint location, GLsizei count, IntPtr value)
+
+        public static
+        void Uniform4fvARB(GLint location, GLsizei count, IntPtr value)
+        {
+            Uniform4fvARB_(location, count, value);
+        }
+
+        #endregion
+
+        #region Uniform4fvARB(GLint location, GLsizei count, object value)
+
+        public static
+        void Uniform4fvARB(GLint location, GLsizei count, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform4fvARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform4fvARB(GLint location, GLsizei count, GLfloat[] value)
+
+        public static
+        void Uniform4fvARB(GLint location, GLsizei count, GLfloat[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform4fvARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform1ivARB(GLint location, GLsizei count, IntPtr value)
+
+        public static
+        void Uniform1ivARB(GLint location, GLsizei count, IntPtr value)
+        {
+            Uniform1ivARB_(location, count, value);
+        }
+
+        #endregion
+
+        #region Uniform1ivARB(GLint location, GLsizei count, object value)
+
+        public static
+        void Uniform1ivARB(GLint location, GLsizei count, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform1ivARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform1ivARB(GLint location, GLsizei count, GLint[] value)
+
+        public static
+        void Uniform1ivARB(GLint location, GLsizei count, GLint[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform1ivARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform2ivARB(GLint location, GLsizei count, IntPtr value)
+
+        public static
+        void Uniform2ivARB(GLint location, GLsizei count, IntPtr value)
+        {
+            Uniform2ivARB_(location, count, value);
+        }
+
+        #endregion
+
+        #region Uniform2ivARB(GLint location, GLsizei count, object value)
+
+        public static
+        void Uniform2ivARB(GLint location, GLsizei count, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform2ivARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform2ivARB(GLint location, GLsizei count, GLint[] value)
+
+        public static
+        void Uniform2ivARB(GLint location, GLsizei count, GLint[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform2ivARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform3ivARB(GLint location, GLsizei count, IntPtr value)
+
+        public static
+        void Uniform3ivARB(GLint location, GLsizei count, IntPtr value)
+        {
+            Uniform3ivARB_(location, count, value);
+        }
+
+        #endregion
+
+        #region Uniform3ivARB(GLint location, GLsizei count, object value)
+
+        public static
+        void Uniform3ivARB(GLint location, GLsizei count, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform3ivARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform3ivARB(GLint location, GLsizei count, GLint[] value)
+
+        public static
+        void Uniform3ivARB(GLint location, GLsizei count, GLint[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform3ivARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform4ivARB(GLint location, GLsizei count, IntPtr value)
+
+        public static
+        void Uniform4ivARB(GLint location, GLsizei count, IntPtr value)
+        {
+            Uniform4ivARB_(location, count, value);
+        }
+
+        #endregion
+
+        #region Uniform4ivARB(GLint location, GLsizei count, object value)
+
+        public static
+        void Uniform4ivARB(GLint location, GLsizei count, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform4ivARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Uniform4ivARB(GLint location, GLsizei count, GLint[] value)
+
+        public static
+        void Uniform4ivARB(GLint location, GLsizei count, GLint[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                Uniform4ivARB_(location, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region UniformMatrix2fvARB(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
+
+        public static
+        void UniformMatrix2fvARB(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
+        {
+            UniformMatrix2fvARB_(location, count, transpose, value);
+        }
+
+        #endregion
+
+        #region UniformMatrix2fvARB(GLint location, GLsizei count, Enums.Boolean transpose, object value)
+
+        public static
+        void UniformMatrix2fvARB(GLint location, GLsizei count, Enums.Boolean transpose, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                UniformMatrix2fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region UniformMatrix2fvARB(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
+
+        public static
+        void UniformMatrix2fvARB(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                UniformMatrix2fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region UniformMatrix3fvARB(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
+
+        public static
+        void UniformMatrix3fvARB(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
+        {
+            UniformMatrix3fvARB_(location, count, transpose, value);
+        }
+
+        #endregion
+
+        #region UniformMatrix3fvARB(GLint location, GLsizei count, Enums.Boolean transpose, object value)
+
+        public static
+        void UniformMatrix3fvARB(GLint location, GLsizei count, Enums.Boolean transpose, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                UniformMatrix3fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region UniformMatrix3fvARB(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
+
+        public static
+        void UniformMatrix3fvARB(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                UniformMatrix3fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region UniformMatrix4fvARB(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
+
+        public static
+        void UniformMatrix4fvARB(GLint location, GLsizei count, Enums.Boolean transpose, IntPtr value)
+        {
+            UniformMatrix4fvARB_(location, count, transpose, value);
+        }
+
+        #endregion
+
+        #region UniformMatrix4fvARB(GLint location, GLsizei count, Enums.Boolean transpose, object value)
+
+        public static
+        void UniformMatrix4fvARB(GLint location, GLsizei count, Enums.Boolean transpose, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                UniformMatrix4fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region UniformMatrix4fvARB(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
+
+        public static
+        void UniformMatrix4fvARB(GLint location, GLsizei count, Enums.Boolean transpose, GLfloat[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                UniformMatrix4fvARB_(location, count, transpose, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters)
+
+        public static
+        void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters)
+        {
+            GetObjectParameterfvARB_(obj, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, object parameters)
+
+        public static
+        void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetObjectParameterfvARB_(obj, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLfloat[] parameters)
+
+        public static
+        void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetObjectParameterfvARB_(obj, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters)
+
+        public static
+        void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, IntPtr parameters)
+        {
+            GetObjectParameterivARB_(obj, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, object parameters)
+
+        public static
+        void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetObjectParameterivARB_(obj, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLint[] parameters)
+
+        public static
+        void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetObjectParameterivARB_(obj, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder infoLog)
+
+        public static
+        void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder infoLog)
+        {
+            GetInfoLogARB_(obj, maxLength, length, infoLog);
+        }
+
+        #endregion
+
+        #region GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, object length, StringBuilder infoLog)
+
+        public static
+        void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, object length, StringBuilder infoLog)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                GetInfoLogARB_(obj, maxLength, h0.AddrOfPinnedObject(), infoLog);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, StringBuilder infoLog)
+
+        public static
+        void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, StringBuilder infoLog)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                GetInfoLogARB_(obj, maxLength, h0.AddrOfPinnedObject(), infoLog);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, IntPtr obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, IntPtr obj)
+        {
+            GetAttachedObjectsARB_(containerObj, maxCount, count, obj);
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, object obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, object obj)
+        {
+            GCHandle h0 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+            try
+            {
+                GetAttachedObjectsARB_(containerObj, maxCount, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, GLhandleARB[] obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, IntPtr count, GLhandleARB[] obj)
+        {
+            GCHandle h0 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+            try
+            {
+                GetAttachedObjectsARB_(containerObj, maxCount, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, IntPtr obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, IntPtr obj)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), obj);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, object obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, object obj)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+            try
+            {
+                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, GLhandleARB[] obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, object count, GLhandleARB[] obj)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+            try
+            {
+                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, IntPtr obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, IntPtr obj)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), obj);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, object obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, object obj)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+            try
+            {
+                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB[] obj)
+
+        public static
+        void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB[] obj)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+            try
+            {
+                GetAttachedObjectsARB_(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name)
+        {
+            GetActiveUniformARB_(programObj, index, maxLength, length, size, type, name);
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, length, size, h0.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, length, size, h0.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, type, name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, type, name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, object type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
+
+        public static
+        void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_shader_objects[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveUniformARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetUniformfvARB(GLhandleARB programObj, GLint location, IntPtr parameters)
+
+        public static
+        void GetUniformfvARB(GLhandleARB programObj, GLint location, IntPtr parameters)
+        {
+            GetUniformfvARB_(programObj, location, parameters);
+        }
+
+        #endregion
+
+        #region GetUniformfvARB(GLhandleARB programObj, GLint location, object parameters)
+
+        public static
+        void GetUniformfvARB(GLhandleARB programObj, GLint location, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetUniformfvARB_(programObj, location, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat[] parameters)
+
+        public static
+        void GetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetUniformfvARB_(programObj, location, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetUniformivARB(GLhandleARB programObj, GLint location, IntPtr parameters)
+
+        public static
+        void GetUniformivARB(GLhandleARB programObj, GLint location, IntPtr parameters)
+        {
+            GetUniformivARB_(programObj, location, parameters);
+        }
+
+        #endregion
+
+        #region GetUniformivARB(GLhandleARB programObj, GLint location, object parameters)
+
+        public static
+        void GetUniformivARB(GLhandleARB programObj, GLint location, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetUniformivARB_(programObj, location, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetUniformivARB(GLhandleARB programObj, GLint location, GLint[] parameters)
+
+        public static
+        void GetUniformivARB(GLhandleARB programObj, GLint location, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetUniformivARB_(programObj, location, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder source)
+
+        public static
+        void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, IntPtr length, StringBuilder source)
+        {
+            GetShaderSourceARB_(obj, maxLength, length, source);
+        }
+
+        #endregion
+
+        #region GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, object length, StringBuilder source)
+
+        public static
+        void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, object length, StringBuilder source)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                GetShaderSourceARB_(obj, maxLength, h0.AddrOfPinnedObject(), source);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, StringBuilder source)
+
+        public static
+        void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, StringBuilder source)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                GetShaderSourceARB_(obj, maxLength, h0.AddrOfPinnedObject(), source);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, IntPtr type, StringBuilder name)
+        {
+            GetActiveAttribARB_(programObj, index, maxLength, length, size, type, name);
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, length, size, h0.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, length, size, h0.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, IntPtr length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, length, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, type, name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, object length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, type, name);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, IntPtr size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), size, h1.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, object size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, IntPtr type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, IntPtr type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, name);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, object type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, object type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+
+        public static
+        void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_vertex_shader[] type, StringBuilder name)
+        {
+            GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+            try
+            {
+                GetActiveAttribARB_(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DrawBuffersARB(GLsizei n, IntPtr bufs)
+
+        public static
+        void DrawBuffersARB(GLsizei n, IntPtr bufs)
+        {
+            DrawBuffersARB_(n, bufs);
+        }
+
+        #endregion
+
+        #region DrawBuffersARB(GLsizei n, object bufs)
+
+        public static
+        void DrawBuffersARB(GLsizei n, object bufs)
+        {
+            GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+            try
+            {
+                DrawBuffersARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DrawBuffersARB(GLsizei n, GLenum[] bufs)
+
+        public static
+        void DrawBuffersARB(GLsizei n, GLenum[] bufs)
+        {
+            GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+            try
+            {
+                DrawBuffersARB_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+
+        public static
+        void TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+        {
+            TexImage3DEXT_(target, level, internalformat, width, height, depth, border, format, type, pixels);
+        }
+
+        #endregion
+
+        #region TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+
+        public static
+        void TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+        {
+            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                TexImage3DEXT_(target, level, internalformat, width, height, depth, border, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+
+        public static
+        void TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+        {
+            TexSubImage3DEXT_(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+        }
+
+        #endregion
+
+        #region TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+
+        public static
+        void TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+        {
+            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                TexSubImage3DEXT_(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, IntPtr weights)
+
+        public static
+        void GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, IntPtr weights)
+        {
+            GetTexFilterFuncSGIS_(target, filter, weights);
+        }
+
+        #endregion
+
+        #region GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, object weights)
+
+        public static
+        void GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                GetTexFilterFuncSGIS_(target, filter, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLfloat[] weights)
+
+        public static
+        void GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLfloat[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                GetTexFilterFuncSGIS_(target, filter, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, IntPtr weights)
+
+        public static
+        void TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, IntPtr weights)
+        {
+            TexFilterFuncSGIS_(target, filter, n, weights);
+        }
+
+        #endregion
+
+        #region TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, object weights)
+
+        public static
+        void TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, object weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                TexFilterFuncSGIS_(target, filter, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, GLfloat[] weights)
+
+        public static
+        void TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, GLfloat[] weights)
+        {
+            GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+            try
+            {
+                TexFilterFuncSGIS_(target, filter, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+
+        public static
+        void TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+        {
+            TexSubImage1DEXT_(target, level, xoffset, width, format, type, pixels);
+        }
+
+        #endregion
+
+        #region TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+
+        public static
+        void TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+        {
+            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                TexSubImage1DEXT_(target, level, xoffset, width, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+
+        public static
+        void TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+        {
+            TexSubImage2DEXT_(target, level, xoffset, yoffset, width, height, format, type, pixels);
+        }
+
+        #endregion
+
+        #region TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+
+        public static
+        void TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+        {
+            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                TexSubImage2DEXT_(target, level, xoffset, yoffset, width, height, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetHistogramEXT(Enums.HistogramTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
+
+        public static
+        void GetHistogramEXT(Enums.HistogramTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
+        {
+            GetHistogramEXT_(target, reset, format, type, values);
+        }
+
+        #endregion
+
+        #region GetHistogramEXT(Enums.HistogramTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+
+        public static
+        void GetHistogramEXT(Enums.HistogramTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+        {
+            GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+            try
+            {
+                GetHistogramEXT_(target, reset, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters)
+
+        public static
+        void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters)
+        {
+            GetHistogramParameterfvEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, object parameters)
+
+        public static
+        void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetHistogramParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLfloat[] parameters)
+
+        public static
+        void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetHistogramParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters)
+
+        public static
+        void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, IntPtr parameters)
+        {
+            GetHistogramParameterivEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, object parameters)
+
+        public static
+        void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetHistogramParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLint[] parameters)
+
+        public static
+        void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetHistogramParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMinmaxEXT(Enums.MinmaxTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
+
+        public static
+        void GetMinmaxEXT(Enums.MinmaxTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, IntPtr values)
+        {
+            GetMinmaxEXT_(target, reset, format, type, values);
+        }
+
+        #endregion
+
+        #region GetMinmaxEXT(Enums.MinmaxTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+
+        public static
+        void GetMinmaxEXT(Enums.MinmaxTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+        {
+            GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+            try
+            {
+                GetMinmaxEXT_(target, reset, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters)
+
+        public static
+        void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters)
+        {
+            GetMinmaxParameterfvEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, object parameters)
+
+        public static
+        void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMinmaxParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLfloat[] parameters)
+
+        public static
+        void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMinmaxParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters)
+
+        public static
+        void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, IntPtr parameters)
+        {
+            GetMinmaxParameterivEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, object parameters)
+
+        public static
+        void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMinmaxParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLint[] parameters)
+
+        public static
+        void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMinmaxParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
+
+        public static
+        void ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
+        {
+            ConvolutionFilter1DEXT_(target, internalformat, width, format, type, image);
+        }
+
+        #endregion
+
+        #region ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object image)
+
+        public static
+        void ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object image)
+        {
+            GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+            try
+            {
+                ConvolutionFilter1DEXT_(target, internalformat, width, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
+
+        public static
+        void ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
+        {
+            ConvolutionFilter2DEXT_(target, internalformat, width, height, format, type, image);
+        }
+
+        #endregion
+
+        #region ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object image)
+
+        public static
+        void ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object image)
+        {
+            GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+            try
+            {
+                ConvolutionFilter2DEXT_(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
+
+        public static
+        void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
+        {
+            ConvolutionParameterfvEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
+
+        public static
+        void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ConvolutionParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] parameters)
+
+        public static
+        void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ConvolutionParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
+
+        public static
+        void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
+        {
+            ConvolutionParameterivEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
+
+        public static
+        void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ConvolutionParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] parameters)
+
+        public static
+        void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ConvolutionParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
+
+        public static
+        void GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr image)
+        {
+            GetConvolutionFilterEXT_(target, format, type, image);
+        }
+
+        #endregion
+
+        #region GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object image)
+
+        public static
+        void GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object image)
+        {
+            GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+            try
+            {
+                GetConvolutionFilterEXT_(target, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
+
+        public static
+        void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
+        {
+            GetConvolutionParameterfvEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
+
+        public static
+        void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetConvolutionParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] parameters)
+
+        public static
+        void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetConvolutionParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
+
+        public static
+        void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, IntPtr parameters)
+        {
+            GetConvolutionParameterivEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
+
+        public static
+        void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetConvolutionParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] parameters)
+
+        public static
+        void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetConvolutionParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, IntPtr span)
+
+        public static
+        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, IntPtr span)
+        {
+            GetSeparableFilterEXT_(target, format, type, row, column, span);
+        }
+
+        #endregion
+
+        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, object span)
+
+        public static
+        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column, object span)
+        {
+            GCHandle h0 = GCHandle.Alloc(span, GCHandleType.Pinned);
+            try
+            {
+                GetSeparableFilterEXT_(target, format, type, row, column, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column, IntPtr span)
+
+        public static
+        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column, IntPtr span)
+        {
+            GCHandle h0 = GCHandle.Alloc(column, GCHandleType.Pinned);
+            try
+            {
+                GetSeparableFilterEXT_(target, format, type, row, h0.AddrOfPinnedObject(), span);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column, object span)
+
+        public static
+        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column, object span)
+        {
+            GCHandle h0 = GCHandle.Alloc(column, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(span, GCHandleType.Pinned);
+            try
+            {
+                GetSeparableFilterEXT_(target, format, type, row, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column, IntPtr span)
+
+        public static
+        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column, IntPtr span)
+        {
+            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+            try
+            {
+                GetSeparableFilterEXT_(target, format, type, h0.AddrOfPinnedObject(), column, span);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column, object span)
+
+        public static
+        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column, object span)
+        {
+            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(span, GCHandleType.Pinned);
+            try
+            {
+                GetSeparableFilterEXT_(target, format, type, h0.AddrOfPinnedObject(), column, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, IntPtr span)
+
+        public static
+        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, IntPtr span)
+        {
+            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+            try
+            {
+                GetSeparableFilterEXT_(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), span);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, object span)
+
+        public static
+        void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, object span)
+        {
+            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+            try
+            {
+                GetSeparableFilterEXT_(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column)
+
+        public static
+        void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column)
+        {
+            SeparableFilter2DEXT_(target, internalformat, width, height, format, type, row, column);
+        }
+
+        #endregion
+
+        #region SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column)
+
+        public static
+        void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, object column)
+        {
+            GCHandle h0 = GCHandle.Alloc(column, GCHandleType.Pinned);
+            try
+            {
+                SeparableFilter2DEXT_(target, internalformat, width, height, format, type, row, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column)
+
+        public static
+        void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, IntPtr column)
+        {
+            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+            try
+            {
+                SeparableFilter2DEXT_(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), column);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, object column)
+
+        public static
+        void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, object column)
+        {
+            GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+            try
+            {
+                SeparableFilter2DEXT_(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
+
+        public static
+        void ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
+        {
+            ColorTableSGI_(target, internalformat, width, format, type, table);
+        }
+
+        #endregion
+
+        #region ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
+
+        public static
+        void ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
+        {
+            GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
+            try
+            {
+                ColorTableSGI_(target, internalformat, width, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters)
+
+        public static
+        void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters)
+        {
+            ColorTableParameterfvSGI_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, object parameters)
+
+        public static
+        void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ColorTableParameterfvSGI_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLfloat[] parameters)
+
+        public static
+        void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ColorTableParameterfvSGI_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters)
+
+        public static
+        void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, IntPtr parameters)
+        {
+            ColorTableParameterivSGI_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, object parameters)
+
+        public static
+        void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ColorTableParameterivSGI_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLint[] parameters)
+
+        public static
+        void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ColorTableParameterivSGI_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
+
+        public static
+        void GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
+        {
+            GetColorTableSGI_(target, format, type, table);
+        }
+
+        #endregion
+
+        #region GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, object table)
+
+        public static
+        void GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, object table)
+        {
+            GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableSGI_(target, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters)
+
+        public static
+        void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters)
+        {
+            GetColorTableParameterfvSGI_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, object parameters)
+
+        public static
+        void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableParameterfvSGI_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLfloat[] parameters)
+
+        public static
+        void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableParameterfvSGI_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters)
+
+        public static
+        void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, IntPtr parameters)
+        {
+            GetColorTableParameterivSGI_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, object parameters)
+
+        public static
+        void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableParameterivSGI_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLint[] parameters)
+
+        public static
+        void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableParameterivSGI_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
+
+        public static
+        void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
+        {
+            PixelTexGenParameterivSGIS_(pname, parameters);
+        }
+
+        #endregion
+
+        #region PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
+
+        public static
+        void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PixelTexGenParameterivSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] parameters)
+
+        public static
+        void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PixelTexGenParameterivSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
+
+        public static
+        void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
+        {
+            PixelTexGenParameterfvSGIS_(pname, parameters);
+        }
+
+        #endregion
+
+        #region PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
+
+        public static
+        void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PixelTexGenParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] parameters)
+
+        public static
+        void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PixelTexGenParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
+
+        public static
+        void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
+        {
+            GetPixelTexGenParameterivSGIS_(pname, parameters);
+        }
+
+        #endregion
+
+        #region GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
+
+        public static
+        void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetPixelTexGenParameterivSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] parameters)
+
+        public static
+        void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetPixelTexGenParameterivSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
+
+        public static
+        void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, IntPtr parameters)
+        {
+            GetPixelTexGenParameterfvSGIS_(pname, parameters);
+        }
+
+        #endregion
+
+        #region GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
+
+        public static
+        void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetPixelTexGenParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] parameters)
+
+        public static
+        void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetPixelTexGenParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+
+        public static
+        void TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+        {
+            TexImage4DSGIS_(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);
+        }
+
+        #endregion
+
+        #region TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+
+        public static
+        void TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+        {
+            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                TexImage4DSGIS_(target, level, internalformat, width, height, depth, size4d, border, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+
+        public static
+        void TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels)
+        {
+            TexSubImage4DSGIS_(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
+        }
+
+        #endregion
+
+        #region TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+
+        public static
+        void TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+        {
+            GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+            try
+            {
+                TexSubImage4DSGIS_(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, IntPtr textures, IntPtr residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, IntPtr textures, IntPtr residences)
+        {
+            return AreTexturesResidentEXT_(n, textures, residences);
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, IntPtr textures, object residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, IntPtr textures, object residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreTexturesResidentEXT_(n, textures, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, IntPtr textures, Enums.Boolean[] residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, IntPtr textures, Enums.Boolean[] residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreTexturesResidentEXT_(n, textures, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, object textures, IntPtr residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, object textures, IntPtr residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            try
+            {
+                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), residences);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, object textures, object residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, object textures, object residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, object textures, Enums.Boolean[] residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, object textures, Enums.Boolean[] residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, GLuint[] textures, IntPtr residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, IntPtr residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            try
+            {
+                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), residences);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, GLuint[] textures, object residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, object residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreTexturesResidentEXT(GLsizei n, GLuint[] textures, Enums.Boolean[] residences)
+
+        public static
+        GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, Enums.Boolean[] residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreTexturesResidentEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteTexturesEXT(GLsizei n, IntPtr textures)
+
+        public static
+        void DeleteTexturesEXT(GLsizei n, IntPtr textures)
+        {
+            DeleteTexturesEXT_(n, textures);
+        }
+
+        #endregion
+
+        #region DeleteTexturesEXT(GLsizei n, object textures)
+
+        public static
+        void DeleteTexturesEXT(GLsizei n, object textures)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            try
+            {
+                DeleteTexturesEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteTexturesEXT(GLsizei n, GLuint[] textures)
+
+        public static
+        void DeleteTexturesEXT(GLsizei n, GLuint[] textures)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            try
+            {
+                DeleteTexturesEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenTexturesEXT(GLsizei n, IntPtr textures)
+
+        public static
+        void GenTexturesEXT(GLsizei n, IntPtr textures)
+        {
+            GenTexturesEXT_(n, textures);
+        }
+
+        #endregion
+
+        #region GenTexturesEXT(GLsizei n, object textures)
+
+        public static
+        void GenTexturesEXT(GLsizei n, object textures)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            try
+            {
+                GenTexturesEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenTexturesEXT(GLsizei n, GLuint[] textures)
+
+        public static
+        void GenTexturesEXT(GLsizei n, GLuint[] textures)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            try
+            {
+                GenTexturesEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, IntPtr textures, IntPtr priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, IntPtr textures, IntPtr priorities)
+        {
+            PrioritizeTexturesEXT_(n, textures, priorities);
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, IntPtr textures, object priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, IntPtr textures, object priorities)
+        {
+            GCHandle h0 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+            try
+            {
+                PrioritizeTexturesEXT_(n, textures, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, IntPtr textures, GLclampf[] priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, IntPtr textures, GLclampf[] priorities)
+        {
+            GCHandle h0 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+            try
+            {
+                PrioritizeTexturesEXT_(n, textures, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, object textures, IntPtr priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, object textures, IntPtr priorities)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            try
+            {
+                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), priorities);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, object textures, object priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, object textures, object priorities)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+            try
+            {
+                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, object textures, GLclampf[] priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, object textures, GLclampf[] priorities)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+            try
+            {
+                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, IntPtr priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, IntPtr priorities)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            try
+            {
+                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), priorities);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, object priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, object priorities)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+            try
+            {
+                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, GLclampf[] priorities)
+
+        public static
+        void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, GLclampf[] priorities)
+        {
+            GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+            try
+            {
+                PrioritizeTexturesEXT_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, IntPtr points)
+
+        public static
+        void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, IntPtr points)
+        {
+            DetailTexFuncSGIS_(target, n, points);
+        }
+
+        #endregion
+
+        #region DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, object points)
+
+        public static
+        void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                DetailTexFuncSGIS_(target, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
+
+        public static
+        void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                DetailTexFuncSGIS_(target, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetDetailTexFuncSGIS(Enums.TextureTarget target, IntPtr points)
+
+        public static
+        void GetDetailTexFuncSGIS(Enums.TextureTarget target, IntPtr points)
+        {
+            GetDetailTexFuncSGIS_(target, points);
+        }
+
+        #endregion
+
+        #region GetDetailTexFuncSGIS(Enums.TextureTarget target, object points)
+
+        public static
+        void GetDetailTexFuncSGIS(Enums.TextureTarget target, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                GetDetailTexFuncSGIS_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetDetailTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
+
+        public static
+        void GetDetailTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                GetDetailTexFuncSGIS_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, IntPtr points)
+
+        public static
+        void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, IntPtr points)
+        {
+            SharpenTexFuncSGIS_(target, n, points);
+        }
+
+        #endregion
+
+        #region SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, object points)
+
+        public static
+        void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                SharpenTexFuncSGIS_(target, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
+
+        public static
+        void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                SharpenTexFuncSGIS_(target, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSharpenTexFuncSGIS(Enums.TextureTarget target, IntPtr points)
+
+        public static
+        void GetSharpenTexFuncSGIS(Enums.TextureTarget target, IntPtr points)
+        {
+            GetSharpenTexFuncSGIS_(target, points);
+        }
+
+        #endregion
+
+        #region GetSharpenTexFuncSGIS(Enums.TextureTarget target, object points)
+
+        public static
+        void GetSharpenTexFuncSGIS(Enums.TextureTarget target, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                GetSharpenTexFuncSGIS_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetSharpenTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
+
+        public static
+        void GetSharpenTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                GetSharpenTexFuncSGIS_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+
+        public static
+        void ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+        {
+            ColorPointerEXT_(size, type, stride, count, pointer);
+        }
+
+        #endregion
+
+        #region ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, object pointer)
+
+        public static
+        void ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ColorPointerEXT_(size, type, stride, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region EdgeFlagPointerEXT(GLsizei stride, GLsizei count, IntPtr pointer)
+
+        public static
+        void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, IntPtr pointer)
+        {
+            EdgeFlagPointerEXT_(stride, count, pointer);
+        }
+
+        #endregion
+
+        #region EdgeFlagPointerEXT(GLsizei stride, GLsizei count, object pointer)
+
+        public static
+        void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                EdgeFlagPointerEXT_(stride, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region EdgeFlagPointerEXT(GLsizei stride, GLsizei count, Enums.Boolean[] pointer)
+
+        public static
+        void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, Enums.Boolean[] pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                EdgeFlagPointerEXT_(stride, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetPointervEXT(Enums.GetPointervPName pname, IntPtr parameters)
+
+        public static
+        void GetPointervEXT(Enums.GetPointervPName pname, IntPtr parameters)
+        {
+            GetPointervEXT_(pname, parameters);
+        }
+
+        #endregion
+
+        #region GetPointervEXT(Enums.GetPointervPName pname, object parameters)
+
+        public static
+        void GetPointervEXT(Enums.GetPointervPName pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetPointervEXT_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetPointervEXT(Enums.GetPointervPName pname, IntPtr[] parameters)
+
+        public static
+        void GetPointervEXT(Enums.GetPointervPName pname, IntPtr[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetPointervEXT_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+
+        public static
+        void IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+        {
+            IndexPointerEXT_(type, stride, count, pointer);
+        }
+
+        #endregion
+
+        #region IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, object pointer)
+
+        public static
+        void IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                IndexPointerEXT_(type, stride, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+
+        public static
+        void NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+        {
+            NormalPointerEXT_(type, stride, count, pointer);
+        }
+
+        #endregion
+
+        #region NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, object pointer)
+
+        public static
+        void NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                NormalPointerEXT_(type, stride, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+
+        public static
+        void TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+        {
+            TexCoordPointerEXT_(size, type, stride, count, pointer);
+        }
+
+        #endregion
+
+        #region TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, object pointer)
+
+        public static
+        void TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                TexCoordPointerEXT_(size, type, stride, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+
+        public static
+        void VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer)
+        {
+            VertexPointerEXT_(size, type, stride, count, pointer);
+        }
+
+        #endregion
+
+        #region VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, object pointer)
+
+        public static
+        void VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexPointerEXT_(size, type, stride, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SpriteParameterfvSGIX(GLenum pname, IntPtr parameters)
+
+        public static
+        void SpriteParameterfvSGIX(GLenum pname, IntPtr parameters)
+        {
+            SpriteParameterfvSGIX_(pname, parameters);
+        }
+
+        #endregion
+
+        #region SpriteParameterfvSGIX(GLenum pname, object parameters)
+
+        public static
+        void SpriteParameterfvSGIX(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                SpriteParameterfvSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SpriteParameterfvSGIX(GLenum pname, GLfloat[] parameters)
+
+        public static
+        void SpriteParameterfvSGIX(GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                SpriteParameterfvSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SpriteParameterivSGIX(GLenum pname, IntPtr parameters)
+
+        public static
+        void SpriteParameterivSGIX(GLenum pname, IntPtr parameters)
+        {
+            SpriteParameterivSGIX_(pname, parameters);
+        }
+
+        #endregion
+
+        #region SpriteParameterivSGIX(GLenum pname, object parameters)
+
+        public static
+        void SpriteParameterivSGIX(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                SpriteParameterivSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SpriteParameterivSGIX(GLenum pname, GLint[] parameters)
+
+        public static
+        void SpriteParameterivSGIX(GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                SpriteParameterivSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PointParameterfvEXT(GLenum pname, IntPtr parameters)
+
+        public static
+        void PointParameterfvEXT(GLenum pname, IntPtr parameters)
+        {
+            PointParameterfvEXT_(pname, parameters);
+        }
+
+        #endregion
+
+        #region PointParameterfvEXT(GLenum pname, object parameters)
+
+        public static
+        void PointParameterfvEXT(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PointParameterfvEXT_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PointParameterfvEXT(GLenum pname, GLfloat[] parameters)
+
+        public static
+        void PointParameterfvEXT(GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PointParameterfvEXT_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PointParameterfvSGIS(GLenum pname, IntPtr parameters)
+
+        public static
+        void PointParameterfvSGIS(GLenum pname, IntPtr parameters)
+        {
+            PointParameterfvSGIS_(pname, parameters);
+        }
+
+        #endregion
+
+        #region PointParameterfvSGIS(GLenum pname, object parameters)
+
+        public static
+        void PointParameterfvSGIS(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PointParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PointParameterfvSGIS(GLenum pname, GLfloat[] parameters)
+
+        public static
+        void PointParameterfvSGIS(GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PointParameterfvSGIS_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region InstrumentsBufferSGIX(GLsizei size, IntPtr buffer)
+
+        public static
+        void InstrumentsBufferSGIX(GLsizei size, IntPtr buffer)
+        {
+            InstrumentsBufferSGIX_(size, buffer);
+        }
+
+        #endregion
+
+        #region InstrumentsBufferSGIX(GLsizei size, object buffer)
+
+        public static
+        void InstrumentsBufferSGIX(GLsizei size, object buffer)
+        {
+            GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+            try
+            {
+                InstrumentsBufferSGIX_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region InstrumentsBufferSGIX(GLsizei size, GLint[] buffer)
+
+        public static
+        void InstrumentsBufferSGIX(GLsizei size, GLint[] buffer)
+        {
+            GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+            try
+            {
+                InstrumentsBufferSGIX_(size, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PollInstrumentsSGIX(IntPtr marker_p)
+
+        public static
+        GLint PollInstrumentsSGIX(IntPtr marker_p)
+        {
+            return PollInstrumentsSGIX_(marker_p);
+        }
+
+        #endregion
+
+        #region PollInstrumentsSGIX(object marker_p)
+
+        public static
+        GLint PollInstrumentsSGIX(object marker_p)
+        {
+            GCHandle h0 = GCHandle.Alloc(marker_p, GCHandleType.Pinned);
+            try
+            {
+                return PollInstrumentsSGIX_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PollInstrumentsSGIX(GLint[] marker_p)
+
+        public static
+        GLint PollInstrumentsSGIX(GLint[] marker_p)
+        {
+            GCHandle h0 = GCHandle.Alloc(marker_p, GCHandleType.Pinned);
+            try
+            {
+                return PollInstrumentsSGIX_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, IntPtr points)
+
+        public static
+        void DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, IntPtr points)
+        {
+            DeformationMap3dSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
+        }
+
+        #endregion
+
+        #region DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, object points)
+
+        public static
+        void DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                DeformationMap3dSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble[] points)
+
+        public static
+        void DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, GLdouble[] points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                DeformationMap3dSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, IntPtr points)
+
+        public static
+        void DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, IntPtr points)
+        {
+            DeformationMap3fSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
+        }
+
+        #endregion
+
+        #region DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, object points)
+
+        public static
+        void DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                DeformationMap3fSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat[] points)
+
+        public static
+        void DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, GLfloat[] points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                DeformationMap3fSGIX_(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReferencePlaneSGIX(IntPtr equation)
+
+        public static
+        void ReferencePlaneSGIX(IntPtr equation)
+        {
+            ReferencePlaneSGIX_(equation);
+        }
+
+        #endregion
+
+        #region ReferencePlaneSGIX(object equation)
+
+        public static
+        void ReferencePlaneSGIX(object equation)
+        {
+            GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
+            try
+            {
+                ReferencePlaneSGIX_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReferencePlaneSGIX(GLdouble[] equation)
+
+        public static
+        void ReferencePlaneSGIX(GLdouble[] equation)
+        {
+            GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
+            try
+            {
+                ReferencePlaneSGIX_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogFuncSGIS(GLsizei n, IntPtr points)
+
+        public static
+        void FogFuncSGIS(GLsizei n, IntPtr points)
+        {
+            FogFuncSGIS_(n, points);
+        }
+
+        #endregion
+
+        #region FogFuncSGIS(GLsizei n, object points)
+
+        public static
+        void FogFuncSGIS(GLsizei n, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                FogFuncSGIS_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogFuncSGIS(GLsizei n, GLfloat[] points)
+
+        public static
+        void FogFuncSGIS(GLsizei n, GLfloat[] points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                FogFuncSGIS_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFogFuncSGIS(IntPtr points)
+
+        public static
+        void GetFogFuncSGIS(IntPtr points)
+        {
+            GetFogFuncSGIS_(points);
+        }
+
+        #endregion
+
+        #region GetFogFuncSGIS(object points)
+
+        public static
+        void GetFogFuncSGIS(object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                GetFogFuncSGIS_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFogFuncSGIS(GLfloat[] points)
+
+        public static
+        void GetFogFuncSGIS(GLfloat[] points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                GetFogFuncSGIS_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ImageTransformParameterivHP(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void ImageTransformParameterivHP(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            ImageTransformParameterivHP_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region ImageTransformParameterivHP(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void ImageTransformParameterivHP(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ImageTransformParameterivHP_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ImageTransformParameterivHP(GLenum target, GLenum pname, GLint[] parameters)
+
+        public static
+        void ImageTransformParameterivHP(GLenum target, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ImageTransformParameterivHP_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ImageTransformParameterfvHP(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void ImageTransformParameterfvHP(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            ImageTransformParameterfvHP_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region ImageTransformParameterfvHP(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void ImageTransformParameterfvHP(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ImageTransformParameterfvHP_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void ImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ImageTransformParameterfvHP_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetImageTransformParameterivHP(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetImageTransformParameterivHP(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetImageTransformParameterivHP_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetImageTransformParameterivHP(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetImageTransformParameterivHP(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetImageTransformParameterivHP_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetImageTransformParameterivHP(GLenum target, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetImageTransformParameterivHP(GLenum target, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetImageTransformParameterivHP_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetImageTransformParameterfvHP(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetImageTransformParameterfvHP(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetImageTransformParameterfvHP_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetImageTransformParameterfvHP(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetImageTransformParameterfvHP(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetImageTransformParameterfvHP_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetImageTransformParameterfvHP_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data)
+
+        public static
+        void ColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data)
+        {
+            ColorSubTableEXT_(target, start, count, format, type, data);
+        }
+
+        #endregion
+
+        #region ColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, object data)
+
+        public static
+        void ColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                ColorSubTableEXT_(target, start, count, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorTableEXT(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
+
+        public static
+        void ColorTableEXT(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table)
+        {
+            ColorTableEXT_(target, internalFormat, width, format, type, table);
+        }
+
+        #endregion
+
+        #region ColorTableEXT(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
+
+        public static
+        void ColorTableEXT(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
+        {
+            GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
+            try
+            {
+                ColorTableEXT_(target, internalFormat, width, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableEXT(GLenum target, Enums.PixelFormat format, Enums.PixelType type, IntPtr data)
+
+        public static
+        void GetColorTableEXT(GLenum target, Enums.PixelFormat format, Enums.PixelType type, IntPtr data)
+        {
+            GetColorTableEXT_(target, format, type, data);
+        }
+
+        #endregion
+
+        #region GetColorTableEXT(GLenum target, Enums.PixelFormat format, Enums.PixelType type, object data)
+
+        public static
+        void GetColorTableEXT(GLenum target, Enums.PixelFormat format, Enums.PixelType type, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableEXT_(target, format, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableParameterivEXT(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetColorTableParameterivEXT(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetColorTableParameterivEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetColorTableParameterivEXT(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetColorTableParameterivEXT(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableParameterivEXT(GLenum target, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetColorTableParameterivEXT(GLenum target, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableParameterfvEXT(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetColorTableParameterfvEXT(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetColorTableParameterfvEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetColorTableParameterfvEXT(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetColorTableParameterfvEXT(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetColorTableParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
+
+        public static
+        void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
+        {
+            GetListParameterfvSGIX_(list, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
+
+        public static
+        void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetListParameterfvSGIX_(list, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] parameters)
+
+        public static
+        void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetListParameterfvSGIX_(list, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
+
+        public static
+        void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
+        {
+            GetListParameterivSGIX_(list, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
+
+        public static
+        void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetListParameterivSGIX_(list, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] parameters)
+
+        public static
+        void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetListParameterivSGIX_(list, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
+
+        public static
+        void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
+        {
+            ListParameterfvSGIX_(list, pname, parameters);
+        }
+
+        #endregion
+
+        #region ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
+
+        public static
+        void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ListParameterfvSGIX_(list, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] parameters)
+
+        public static
+        void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ListParameterfvSGIX_(list, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
+
+        public static
+        void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, IntPtr parameters)
+        {
+            ListParameterivSGIX_(list, pname, parameters);
+        }
+
+        #endregion
+
+        #region ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
+
+        public static
+        void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ListParameterivSGIX_(list, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] parameters)
+
+        public static
+        void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ListParameterivSGIX_(list, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CullParameterdvEXT(GLenum pname, IntPtr parameters)
+
+        public static
+        void CullParameterdvEXT(GLenum pname, IntPtr parameters)
+        {
+            CullParameterdvEXT_(pname, parameters);
+        }
+
+        #endregion
+
+        #region CullParameterdvEXT(GLenum pname, object parameters)
+
+        public static
+        void CullParameterdvEXT(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CullParameterdvEXT_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CullParameterdvEXT(GLenum pname, GLdouble[] parameters)
+
+        public static
+        void CullParameterdvEXT(GLenum pname, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CullParameterdvEXT_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CullParameterfvEXT(GLenum pname, IntPtr parameters)
+
+        public static
+        void CullParameterfvEXT(GLenum pname, IntPtr parameters)
+        {
+            CullParameterfvEXT_(pname, parameters);
+        }
+
+        #endregion
+
+        #region CullParameterfvEXT(GLenum pname, object parameters)
+
+        public static
+        void CullParameterfvEXT(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CullParameterfvEXT_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CullParameterfvEXT(GLenum pname, GLfloat[] parameters)
+
+        public static
+        void CullParameterfvEXT(GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CullParameterfvEXT_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentLightfvSGIX(GLenum light, GLenum pname, IntPtr parameters)
+
+        public static
+        void FragmentLightfvSGIX(GLenum light, GLenum pname, IntPtr parameters)
+        {
+            FragmentLightfvSGIX_(light, pname, parameters);
+        }
+
+        #endregion
+
+        #region FragmentLightfvSGIX(GLenum light, GLenum pname, object parameters)
+
+        public static
+        void FragmentLightfvSGIX(GLenum light, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentLightfvSGIX_(light, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void FragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentLightfvSGIX_(light, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentLightivSGIX(GLenum light, GLenum pname, IntPtr parameters)
+
+        public static
+        void FragmentLightivSGIX(GLenum light, GLenum pname, IntPtr parameters)
+        {
+            FragmentLightivSGIX_(light, pname, parameters);
+        }
+
+        #endregion
+
+        #region FragmentLightivSGIX(GLenum light, GLenum pname, object parameters)
+
+        public static
+        void FragmentLightivSGIX(GLenum light, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentLightivSGIX_(light, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentLightivSGIX(GLenum light, GLenum pname, GLint[] parameters)
+
+        public static
+        void FragmentLightivSGIX(GLenum light, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentLightivSGIX_(light, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters)
+
+        public static
+        void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters)
+        {
+            FragmentLightModelfvSGIX_(pname, parameters);
+        }
+
+        #endregion
+
+        #region FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, object parameters)
+
+        public static
+        void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentLightModelfvSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat[] parameters)
+
+        public static
+        void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentLightModelfvSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters)
+
+        public static
+        void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, IntPtr parameters)
+        {
+            FragmentLightModelivSGIX_(pname, parameters);
+        }
+
+        #endregion
+
+        #region FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, object parameters)
+
+        public static
+        void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentLightModelivSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint[] parameters)
+
+        public static
+        void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentLightModelivSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
+
+        public static
+        void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
+        {
+            FragmentMaterialfvSGIX_(face, pname, parameters);
+        }
+
+        #endregion
+
+        #region FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
+
+        public static
+        void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentMaterialfvSGIX_(face, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] parameters)
+
+        public static
+        void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentMaterialfvSGIX_(face, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
+
+        public static
+        void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
+        {
+            FragmentMaterialivSGIX_(face, pname, parameters);
+        }
+
+        #endregion
+
+        #region FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
+
+        public static
+        void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentMaterialivSGIX_(face, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] parameters)
+
+        public static
+        void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                FragmentMaterialivSGIX_(face, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFragmentLightfvSGIX(GLenum light, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetFragmentLightfvSGIX(GLenum light, GLenum pname, IntPtr parameters)
+        {
+            GetFragmentLightfvSGIX_(light, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetFragmentLightfvSGIX(GLenum light, GLenum pname, object parameters)
+
+        public static
+        void GetFragmentLightfvSGIX(GLenum light, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFragmentLightfvSGIX_(light, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFragmentLightfvSGIX_(light, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFragmentLightivSGIX(GLenum light, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetFragmentLightivSGIX(GLenum light, GLenum pname, IntPtr parameters)
+        {
+            GetFragmentLightivSGIX_(light, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetFragmentLightivSGIX(GLenum light, GLenum pname, object parameters)
+
+        public static
+        void GetFragmentLightivSGIX(GLenum light, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFragmentLightivSGIX_(light, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFragmentLightivSGIX(GLenum light, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetFragmentLightivSGIX(GLenum light, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFragmentLightivSGIX_(light, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
+
+        public static
+        void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
+        {
+            GetFragmentMaterialfvSGIX_(face, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
+
+        public static
+        void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFragmentMaterialfvSGIX_(face, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] parameters)
+
+        public static
+        void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFragmentMaterialfvSGIX_(face, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
+
+        public static
+        void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, IntPtr parameters)
+        {
+            GetFragmentMaterialivSGIX_(face, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
+
+        public static
+        void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFragmentMaterialivSGIX_(face, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] parameters)
+
+        public static
+        void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFragmentMaterialivSGIX_(face, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices)
+
+        public static
+        void DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices)
+        {
+            DrawRangeElementsEXT_(mode, start, end, count, type, indices);
+        }
+
+        #endregion
+
+        #region DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, object indices)
+
+        public static
+        void DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, object indices)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                DrawRangeElementsEXT_(mode, start, end, count, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FinishAsyncSGIX(IntPtr markerp)
+
+        public static
+        GLint FinishAsyncSGIX(IntPtr markerp)
+        {
+            return FinishAsyncSGIX_(markerp);
+        }
+
+        #endregion
+
+        #region FinishAsyncSGIX(object markerp)
+
+        public static
+        GLint FinishAsyncSGIX(object markerp)
+        {
+            GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
+            try
+            {
+                return FinishAsyncSGIX_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FinishAsyncSGIX(GLuint[] markerp)
+
+        public static
+        GLint FinishAsyncSGIX(GLuint[] markerp)
+        {
+            GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
+            try
+            {
+                return FinishAsyncSGIX_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PollAsyncSGIX(IntPtr markerp)
+
+        public static
+        GLint PollAsyncSGIX(IntPtr markerp)
+        {
+            return PollAsyncSGIX_(markerp);
+        }
+
+        #endregion
+
+        #region PollAsyncSGIX(object markerp)
+
+        public static
+        GLint PollAsyncSGIX(object markerp)
+        {
+            GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
+            try
+            {
+                return PollAsyncSGIX_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PollAsyncSGIX(GLuint[] markerp)
+
+        public static
+        GLint PollAsyncSGIX(GLuint[] markerp)
+        {
+            GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
+            try
+            {
+                return PollAsyncSGIX_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
+
+        public static
+        void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
+        {
+            VertexPointervINTEL_(size, type, pointer);
+        }
+
+        #endregion
+
+        #region VertexPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
+
+        public static
+        void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexPointervINTEL_(size, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
+
+        public static
+        void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexPointervINTEL_(size, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalPointervINTEL(Enums.NormalPointerType type, IntPtr pointer)
+
+        public static
+        void NormalPointervINTEL(Enums.NormalPointerType type, IntPtr pointer)
+        {
+            NormalPointervINTEL_(type, pointer);
+        }
+
+        #endregion
+
+        #region NormalPointervINTEL(Enums.NormalPointerType type, object pointer)
+
+        public static
+        void NormalPointervINTEL(Enums.NormalPointerType type, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                NormalPointervINTEL_(type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalPointervINTEL(Enums.NormalPointerType type, IntPtr[] pointer)
+
+        public static
+        void NormalPointervINTEL(Enums.NormalPointerType type, IntPtr[] pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                NormalPointervINTEL_(type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
+
+        public static
+        void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
+        {
+            ColorPointervINTEL_(size, type, pointer);
+        }
+
+        #endregion
+
+        #region ColorPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
+
+        public static
+        void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ColorPointervINTEL_(size, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
+
+        public static
+        void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ColorPointervINTEL_(size, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
+
+        public static
+        void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr pointer)
+        {
+            TexCoordPointervINTEL_(size, type, pointer);
+        }
+
+        #endregion
+
+        #region TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
+
+        public static
+        void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                TexCoordPointervINTEL_(size, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
+
+        public static
+        void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, IntPtr[] pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                TexCoordPointervINTEL_(size, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelTransformParameterivEXT(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void PixelTransformParameterivEXT(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            PixelTransformParameterivEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region PixelTransformParameterivEXT(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void PixelTransformParameterivEXT(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PixelTransformParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelTransformParameterivEXT(GLenum target, GLenum pname, GLint[] parameters)
+
+        public static
+        void PixelTransformParameterivEXT(GLenum target, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PixelTransformParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelTransformParameterfvEXT(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void PixelTransformParameterfvEXT(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            PixelTransformParameterfvEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region PixelTransformParameterfvEXT(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void PixelTransformParameterfvEXT(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PixelTransformParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelTransformParameterfvEXT(GLenum target, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void PixelTransformParameterfvEXT(GLenum target, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PixelTransformParameterfvEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3bvEXT(IntPtr v)
+
+        public static
+        void SecondaryColor3bvEXT(IntPtr v)
+        {
+            SecondaryColor3bvEXT_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3bvEXT(object v)
+
+        public static
+        void SecondaryColor3bvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3bvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3bvEXT(GLbyte[] v)
+
+        public static
+        void SecondaryColor3bvEXT(GLbyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3bvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3dvEXT(IntPtr v)
+
+        public static
+        void SecondaryColor3dvEXT(IntPtr v)
+        {
+            SecondaryColor3dvEXT_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3dvEXT(object v)
+
+        public static
+        void SecondaryColor3dvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3dvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3dvEXT(GLdouble[] v)
+
+        public static
+        void SecondaryColor3dvEXT(GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3dvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3fvEXT(IntPtr v)
+
+        public static
+        void SecondaryColor3fvEXT(IntPtr v)
+        {
+            SecondaryColor3fvEXT_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3fvEXT(object v)
+
+        public static
+        void SecondaryColor3fvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3fvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3fvEXT(GLfloat[] v)
+
+        public static
+        void SecondaryColor3fvEXT(GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3fvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3ivEXT(IntPtr v)
+
+        public static
+        void SecondaryColor3ivEXT(IntPtr v)
+        {
+            SecondaryColor3ivEXT_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3ivEXT(object v)
+
+        public static
+        void SecondaryColor3ivEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3ivEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3ivEXT(GLint[] v)
+
+        public static
+        void SecondaryColor3ivEXT(GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3ivEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3svEXT(IntPtr v)
+
+        public static
+        void SecondaryColor3svEXT(IntPtr v)
+        {
+            SecondaryColor3svEXT_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3svEXT(object v)
+
+        public static
+        void SecondaryColor3svEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3svEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3svEXT(GLshort[] v)
+
+        public static
+        void SecondaryColor3svEXT(GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3svEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3ubvEXT(IntPtr v)
+
+        public static
+        void SecondaryColor3ubvEXT(IntPtr v)
+        {
+            SecondaryColor3ubvEXT_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3ubvEXT(object v)
+
+        public static
+        void SecondaryColor3ubvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3ubvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3ubvEXT(GLubyte[] v)
+
+        public static
+        void SecondaryColor3ubvEXT(GLubyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3ubvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3uivEXT(IntPtr v)
+
+        public static
+        void SecondaryColor3uivEXT(IntPtr v)
+        {
+            SecondaryColor3uivEXT_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3uivEXT(object v)
+
+        public static
+        void SecondaryColor3uivEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3uivEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3uivEXT(GLuint[] v)
+
+        public static
+        void SecondaryColor3uivEXT(GLuint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3uivEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3usvEXT(IntPtr v)
+
+        public static
+        void SecondaryColor3usvEXT(IntPtr v)
+        {
+            SecondaryColor3usvEXT_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3usvEXT(object v)
+
+        public static
+        void SecondaryColor3usvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3usvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3usvEXT(GLushort[] v)
+
+        public static
+        void SecondaryColor3usvEXT(GLushort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3usvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer)
+        {
+            SecondaryColorPointerEXT_(size, type, stride, pointer);
+        }
+
+        #endregion
+
+        #region SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer)
+
+        public static
+        void SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColorPointerEXT_(size, type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount)
+        {
+            MultiDrawArraysEXT_(mode, first, count, primcount);
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawArraysEXT_(mode, first, h0.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, IntPtr first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawArraysEXT_(mode, first, h0.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, object first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, object first, IntPtr count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), count, primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, object first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, object first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, object first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, object first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, IntPtr count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), count, primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawArraysEXT_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount)
+        {
+            MultiDrawElementsEXT_(mode, count, type, indices, primcount);
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, object indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, object indices, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementsEXT_(mode, count, type, h0.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr[] indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, IntPtr count, GLenum type, IntPtr[] indices, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementsEXT_(mode, count, type, h0.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, IntPtr indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, IntPtr indices, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, indices, primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, object indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, object indices, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, IntPtr[] indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, object count, GLenum type, IntPtr[] indices, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, indices, primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, IntPtr[] indices, GLsizei primcount)
+
+        public static
+        void MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, GLenum type, IntPtr[] indices, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementsEXT_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoordfvEXT(IntPtr coord)
+
+        public static
+        void FogCoordfvEXT(IntPtr coord)
+        {
+            FogCoordfvEXT_(coord);
+        }
+
+        #endregion
+
+        #region FogCoordfvEXT(object coord)
+
+        public static
+        void FogCoordfvEXT(object coord)
+        {
+            GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+            try
+            {
+                FogCoordfvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoordfvEXT(GLfloat[] coord)
+
+        public static
+        void FogCoordfvEXT(GLfloat[] coord)
+        {
+            GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+            try
+            {
+                FogCoordfvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoorddvEXT(IntPtr coord)
+
+        public static
+        void FogCoorddvEXT(IntPtr coord)
+        {
+            FogCoorddvEXT_(coord);
+        }
+
+        #endregion
+
+        #region FogCoorddvEXT(object coord)
+
+        public static
+        void FogCoorddvEXT(object coord)
+        {
+            GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+            try
+            {
+                FogCoorddvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoorddvEXT(GLdouble[] coord)
+
+        public static
+        void FogCoorddvEXT(GLdouble[] coord)
+        {
+            GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+            try
+            {
+                FogCoorddvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoordPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void FogCoordPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
+        {
+            FogCoordPointerEXT_(type, stride, pointer);
+        }
+
+        #endregion
+
+        #region FogCoordPointerEXT(GLenum type, GLsizei stride, object pointer)
+
+        public static
+        void FogCoordPointerEXT(GLenum type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                FogCoordPointerEXT_(type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3bvEXT(IntPtr v)
+
+        public static
+        void Tangent3bvEXT(IntPtr v)
+        {
+            Tangent3bvEXT_(v);
+        }
+
+        #endregion
+
+        #region Tangent3bvEXT(object v)
+
+        public static
+        void Tangent3bvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3bvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3bvEXT(GLbyte[] v)
+
+        public static
+        void Tangent3bvEXT(GLbyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3bvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3dvEXT(IntPtr v)
+
+        public static
+        void Tangent3dvEXT(IntPtr v)
+        {
+            Tangent3dvEXT_(v);
+        }
+
+        #endregion
+
+        #region Tangent3dvEXT(object v)
+
+        public static
+        void Tangent3dvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3dvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3dvEXT(GLdouble[] v)
+
+        public static
+        void Tangent3dvEXT(GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3dvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3fvEXT(IntPtr v)
+
+        public static
+        void Tangent3fvEXT(IntPtr v)
+        {
+            Tangent3fvEXT_(v);
+        }
+
+        #endregion
+
+        #region Tangent3fvEXT(object v)
+
+        public static
+        void Tangent3fvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3fvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3fvEXT(GLfloat[] v)
+
+        public static
+        void Tangent3fvEXT(GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3fvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3ivEXT(IntPtr v)
+
+        public static
+        void Tangent3ivEXT(IntPtr v)
+        {
+            Tangent3ivEXT_(v);
+        }
+
+        #endregion
+
+        #region Tangent3ivEXT(object v)
+
+        public static
+        void Tangent3ivEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3ivEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3ivEXT(GLint[] v)
+
+        public static
+        void Tangent3ivEXT(GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3ivEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3svEXT(IntPtr v)
+
+        public static
+        void Tangent3svEXT(IntPtr v)
+        {
+            Tangent3svEXT_(v);
+        }
+
+        #endregion
+
+        #region Tangent3svEXT(object v)
+
+        public static
+        void Tangent3svEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3svEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Tangent3svEXT(GLshort[] v)
+
+        public static
+        void Tangent3svEXT(GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Tangent3svEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3bvEXT(IntPtr v)
+
+        public static
+        void Binormal3bvEXT(IntPtr v)
+        {
+            Binormal3bvEXT_(v);
+        }
+
+        #endregion
+
+        #region Binormal3bvEXT(object v)
+
+        public static
+        void Binormal3bvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3bvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3bvEXT(GLbyte[] v)
+
+        public static
+        void Binormal3bvEXT(GLbyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3bvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3dvEXT(IntPtr v)
+
+        public static
+        void Binormal3dvEXT(IntPtr v)
+        {
+            Binormal3dvEXT_(v);
+        }
+
+        #endregion
+
+        #region Binormal3dvEXT(object v)
+
+        public static
+        void Binormal3dvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3dvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3dvEXT(GLdouble[] v)
+
+        public static
+        void Binormal3dvEXT(GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3dvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3fvEXT(IntPtr v)
+
+        public static
+        void Binormal3fvEXT(IntPtr v)
+        {
+            Binormal3fvEXT_(v);
+        }
+
+        #endregion
+
+        #region Binormal3fvEXT(object v)
+
+        public static
+        void Binormal3fvEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3fvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3fvEXT(GLfloat[] v)
+
+        public static
+        void Binormal3fvEXT(GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3fvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3ivEXT(IntPtr v)
+
+        public static
+        void Binormal3ivEXT(IntPtr v)
+        {
+            Binormal3ivEXT_(v);
+        }
+
+        #endregion
+
+        #region Binormal3ivEXT(object v)
+
+        public static
+        void Binormal3ivEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3ivEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3ivEXT(GLint[] v)
+
+        public static
+        void Binormal3ivEXT(GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3ivEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3svEXT(IntPtr v)
+
+        public static
+        void Binormal3svEXT(IntPtr v)
+        {
+            Binormal3svEXT_(v);
+        }
+
+        #endregion
+
+        #region Binormal3svEXT(object v)
+
+        public static
+        void Binormal3svEXT(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3svEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Binormal3svEXT(GLshort[] v)
+
+        public static
+        void Binormal3svEXT(GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Binormal3svEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TangentPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void TangentPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
+        {
+            TangentPointerEXT_(type, stride, pointer);
+        }
+
+        #endregion
+
+        #region TangentPointerEXT(GLenum type, GLsizei stride, object pointer)
+
+        public static
+        void TangentPointerEXT(GLenum type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                TangentPointerEXT_(type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region BinormalPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void BinormalPointerEXT(GLenum type, GLsizei stride, IntPtr pointer)
+        {
+            BinormalPointerEXT_(type, stride, pointer);
+        }
+
+        #endregion
+
+        #region BinormalPointerEXT(GLenum type, GLsizei stride, object pointer)
+
+        public static
+        void BinormalPointerEXT(GLenum type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                BinormalPointerEXT_(type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuivSUN(IntPtr code)
+
+        public static
+        void ReplacementCodeuivSUN(IntPtr code)
+        {
+            ReplacementCodeuivSUN_(code);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuivSUN(object code)
+
+        public static
+        void ReplacementCodeuivSUN(object code)
+        {
+            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuivSUN_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuivSUN(GLuint[] code)
+
+        public static
+        void ReplacementCodeuivSUN(GLuint[] code)
+        {
+            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuivSUN_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeusvSUN(IntPtr code)
+
+        public static
+        void ReplacementCodeusvSUN(IntPtr code)
+        {
+            ReplacementCodeusvSUN_(code);
+        }
+
+        #endregion
+
+        #region ReplacementCodeusvSUN(object code)
+
+        public static
+        void ReplacementCodeusvSUN(object code)
+        {
+            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeusvSUN_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeusvSUN(GLushort[] code)
+
+        public static
+        void ReplacementCodeusvSUN(GLushort[] code)
+        {
+            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeusvSUN_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeubvSUN(IntPtr code)
+
+        public static
+        void ReplacementCodeubvSUN(IntPtr code)
+        {
+            ReplacementCodeubvSUN_(code);
+        }
+
+        #endregion
+
+        #region ReplacementCodeubvSUN(object code)
+
+        public static
+        void ReplacementCodeubvSUN(object code)
+        {
+            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeubvSUN_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeubvSUN(GLubyte[] code)
+
+        public static
+        void ReplacementCodeubvSUN(GLubyte[] code)
+        {
+            GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeubvSUN_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodePointerSUN(GLenum type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void ReplacementCodePointerSUN(GLenum type, GLsizei stride, IntPtr pointer)
+        {
+            ReplacementCodePointerSUN_(type, stride, pointer);
+        }
+
+        #endregion
+
+        #region ReplacementCodePointerSUN(GLenum type, GLsizei stride, object pointer)
+
+        public static
+        void ReplacementCodePointerSUN(GLenum type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodePointerSUN_(type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodePointerSUN(GLenum type, GLsizei stride, IntPtr[] pointer)
+
+        public static
+        void ReplacementCodePointerSUN(GLenum type, GLsizei stride, IntPtr[] pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodePointerSUN_(type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(IntPtr c, IntPtr v)
+
+        public static
+        void Color4ubVertex2fvSUN(IntPtr c, IntPtr v)
+        {
+            Color4ubVertex2fvSUN_(c, v);
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(IntPtr c, object v)
+
+        public static
+        void Color4ubVertex2fvSUN(IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex2fvSUN_(c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(IntPtr c, GLfloat[] v)
+
+        public static
+        void Color4ubVertex2fvSUN(IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex2fvSUN_(c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(object c, IntPtr v)
+
+        public static
+        void Color4ubVertex2fvSUN(object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(object c, object v)
+
+        public static
+        void Color4ubVertex2fvSUN(object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(object c, GLfloat[] v)
+
+        public static
+        void Color4ubVertex2fvSUN(object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(GLubyte[] c, IntPtr v)
+
+        public static
+        void Color4ubVertex2fvSUN(GLubyte[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(GLubyte[] c, object v)
+
+        public static
+        void Color4ubVertex2fvSUN(GLubyte[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex2fvSUN(GLubyte[] c, GLfloat[] v)
+
+        public static
+        void Color4ubVertex2fvSUN(GLubyte[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex2fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(IntPtr c, IntPtr v)
+
+        public static
+        void Color4ubVertex3fvSUN(IntPtr c, IntPtr v)
+        {
+            Color4ubVertex3fvSUN_(c, v);
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(IntPtr c, object v)
+
+        public static
+        void Color4ubVertex3fvSUN(IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex3fvSUN_(c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(IntPtr c, GLfloat[] v)
+
+        public static
+        void Color4ubVertex3fvSUN(IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex3fvSUN_(c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(object c, IntPtr v)
+
+        public static
+        void Color4ubVertex3fvSUN(object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(object c, object v)
+
+        public static
+        void Color4ubVertex3fvSUN(object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(object c, GLfloat[] v)
+
+        public static
+        void Color4ubVertex3fvSUN(object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(GLubyte[] c, IntPtr v)
+
+        public static
+        void Color4ubVertex3fvSUN(GLubyte[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(GLubyte[] c, object v)
+
+        public static
+        void Color4ubVertex3fvSUN(GLubyte[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4ubVertex3fvSUN(GLubyte[] c, GLfloat[] v)
+
+        public static
+        void Color4ubVertex3fvSUN(GLubyte[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(IntPtr c, IntPtr v)
+
+        public static
+        void Color3fVertex3fvSUN(IntPtr c, IntPtr v)
+        {
+            Color3fVertex3fvSUN_(c, v);
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(IntPtr c, object v)
+
+        public static
+        void Color3fVertex3fvSUN(IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color3fVertex3fvSUN_(c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(IntPtr c, GLfloat[] v)
+
+        public static
+        void Color3fVertex3fvSUN(IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color3fVertex3fvSUN_(c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(object c, IntPtr v)
+
+        public static
+        void Color3fVertex3fvSUN(object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(object c, object v)
+
+        public static
+        void Color3fVertex3fvSUN(object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(object c, GLfloat[] v)
+
+        public static
+        void Color3fVertex3fvSUN(object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(GLfloat[] c, IntPtr v)
+
+        public static
+        void Color3fVertex3fvSUN(GLfloat[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(GLfloat[] c, object v)
+
+        public static
+        void Color3fVertex3fvSUN(GLfloat[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3fVertex3fvSUN(GLfloat[] c, GLfloat[] v)
+
+        public static
+        void Color3fVertex3fvSUN(GLfloat[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(IntPtr n, IntPtr v)
+
+        public static
+        void Normal3fVertex3fvSUN(IntPtr n, IntPtr v)
+        {
+            Normal3fVertex3fvSUN_(n, v);
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(IntPtr n, object v)
+
+        public static
+        void Normal3fVertex3fvSUN(IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Normal3fVertex3fvSUN_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(IntPtr n, GLfloat[] v)
+
+        public static
+        void Normal3fVertex3fvSUN(IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Normal3fVertex3fvSUN_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(object n, IntPtr v)
+
+        public static
+        void Normal3fVertex3fvSUN(object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(object n, object v)
+
+        public static
+        void Normal3fVertex3fvSUN(object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(object n, GLfloat[] v)
+
+        public static
+        void Normal3fVertex3fvSUN(object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(GLfloat[] n, IntPtr v)
+
+        public static
+        void Normal3fVertex3fvSUN(GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(GLfloat[] n, object v)
+
+        public static
+        void Normal3fVertex3fvSUN(GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3fVertex3fvSUN(GLfloat[] n, GLfloat[] v)
+
+        public static
+        void Normal3fVertex3fvSUN(GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Normal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, IntPtr v)
+        {
+            Color4fNormal3fVertex3fvSUN_(c, n, v);
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, object n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, object n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, IntPtr n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, IntPtr n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, object n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, object n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, object n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(IntPtr tc, IntPtr v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(IntPtr tc, IntPtr v)
+        {
+            TexCoord2fVertex3fvSUN_(tc, v);
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(IntPtr tc, object v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(IntPtr tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fVertex3fvSUN_(tc, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(IntPtr tc, GLfloat[] v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(IntPtr tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fVertex3fvSUN_(tc, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(object tc, IntPtr v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(object tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(object tc, object v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(object tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(object tc, GLfloat[] v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(object tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(GLfloat[] tc, IntPtr v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(GLfloat[] tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(GLfloat[] tc, object v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(GLfloat[] tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fVertex3fvSUN(GLfloat[] tc, GLfloat[] v)
+
+        public static
+        void TexCoord2fVertex3fvSUN(GLfloat[] tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(IntPtr tc, IntPtr v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(IntPtr tc, IntPtr v)
+        {
+            TexCoord4fVertex4fvSUN_(tc, v);
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(IntPtr tc, object v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(IntPtr tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fVertex4fvSUN_(tc, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(IntPtr tc, GLfloat[] v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(IntPtr tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fVertex4fvSUN_(tc, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(object tc, IntPtr v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(object tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(object tc, object v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(object tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(object tc, GLfloat[] v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(object tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(GLfloat[] tc, IntPtr v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(GLfloat[] tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(GLfloat[] tc, object v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(GLfloat[] tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fVertex4fvSUN(GLfloat[] tc, GLfloat[] v)
+
+        public static
+        void TexCoord4fVertex4fvSUN(GLfloat[] tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
+        {
+            TexCoord2fColor4ubVertex3fvSUN_(tc, c, v);
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(IntPtr tc, GLubyte[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, object c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, object c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, object c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(object tc, GLubyte[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, IntPtr v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, object v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
+        {
+            TexCoord2fColor3fVertex3fvSUN_(tc, c, v);
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, object c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, object c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, object c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, IntPtr v)
+        {
+            TexCoord2fNormal3fVertex3fvSUN_(tc, n, v);
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(tc, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(tc, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, object n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, object n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(object tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, n, v);
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, n, v);
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4fColor4fNormal3fVertex4fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(IntPtr rc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(IntPtr rc, IntPtr v)
+        {
+            ReplacementCodeuiVertex3fvSUN_(rc, v);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(IntPtr rc, object v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(IntPtr rc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiVertex3fvSUN_(rc, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(IntPtr rc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(IntPtr rc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiVertex3fvSUN_(rc, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(object rc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(object rc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(object rc, object v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(object rc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(object rc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(object rc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(GLuint[] rc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(GLuint[] rc, object v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiVertex3fvSUN(GLuint[] rc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
+        {
+            ReplacementCodeuiColor4ubVertex3fvSUN_(rc, c, v);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, GLubyte[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(object rc, GLubyte[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, object v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4ubVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
+        {
+            ReplacementCodeuiColor3fVertex3fvSUN_(rc, c, v);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, IntPtr v)
+        {
+            ReplacementCodeuiNormal3fVertex3fvSUN_(rc, n, v);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(object rc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, n, v);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr v)
+        {
+            ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, tc, v);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, object tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, IntPtr v)
+        {
+            ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, n, v);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, n, v);
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(object rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, object tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, IntPtr c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, object c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, IntPtr n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, object n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+
+        public static
+        void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+            GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+            GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h4.Free();
+                h3.Free();
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexWeightfvEXT(IntPtr weight)
+
+        public static
+        void VertexWeightfvEXT(IntPtr weight)
+        {
+            VertexWeightfvEXT_(weight);
+        }
+
+        #endregion
+
+        #region VertexWeightfvEXT(object weight)
+
+        public static
+        void VertexWeightfvEXT(object weight)
+        {
+            GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
+            try
+            {
+                VertexWeightfvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexWeightfvEXT(GLfloat[] weight)
+
+        public static
+        void VertexWeightfvEXT(GLfloat[] weight)
+        {
+            GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
+            try
+            {
+                VertexWeightfvEXT_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void VertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, IntPtr pointer)
+        {
+            VertexWeightPointerEXT_(size, type, stride, pointer);
+        }
+
+        #endregion
+
+        #region VertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, object pointer)
+
+        public static
+        void VertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexWeightPointerEXT_(size, type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexArrayRangeNV(GLsizei length, IntPtr pointer)
+
+        public static
+        void VertexArrayRangeNV(GLsizei length, IntPtr pointer)
+        {
+            VertexArrayRangeNV_(length, pointer);
+        }
+
+        #endregion
+
+        #region VertexArrayRangeNV(GLsizei length, object pointer)
+
+        public static
+        void VertexArrayRangeNV(GLsizei length, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexArrayRangeNV_(length, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CombinerParameterfvNV(GLenum pname, IntPtr parameters)
+
+        public static
+        void CombinerParameterfvNV(GLenum pname, IntPtr parameters)
+        {
+            CombinerParameterfvNV_(pname, parameters);
+        }
+
+        #endregion
+
+        #region CombinerParameterfvNV(GLenum pname, object parameters)
+
+        public static
+        void CombinerParameterfvNV(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CombinerParameterfvNV_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CombinerParameterfvNV(GLenum pname, GLfloat[] parameters)
+
+        public static
+        void CombinerParameterfvNV(GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CombinerParameterfvNV_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CombinerParameterivNV(GLenum pname, IntPtr parameters)
+
+        public static
+        void CombinerParameterivNV(GLenum pname, IntPtr parameters)
+        {
+            CombinerParameterivNV_(pname, parameters);
+        }
+
+        #endregion
+
+        #region CombinerParameterivNV(GLenum pname, object parameters)
+
+        public static
+        void CombinerParameterivNV(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CombinerParameterivNV_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CombinerParameterivNV(GLenum pname, GLint[] parameters)
+
+        public static
+        void CombinerParameterivNV(GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CombinerParameterivNV_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters)
+        {
+            GetCombinerInputParameterfvNV_(stage, portion, variable, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, object parameters)
+
+        public static
+        void GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerInputParameterfvNV_(stage, portion, variable, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerInputParameterfvNV_(stage, portion, variable, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, IntPtr parameters)
+        {
+            GetCombinerInputParameterivNV_(stage, portion, variable, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, object parameters)
+
+        public static
+        void GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerInputParameterivNV_(stage, portion, variable, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerInputParameterivNV_(stage, portion, variable, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters)
+        {
+            GetCombinerOutputParameterfvNV_(stage, portion, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, object parameters)
+
+        public static
+        void GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerOutputParameterfvNV_(stage, portion, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerOutputParameterfvNV_(stage, portion, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, IntPtr parameters)
+        {
+            GetCombinerOutputParameterivNV_(stage, portion, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, object parameters)
+
+        public static
+        void GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerOutputParameterivNV_(stage, portion, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerOutputParameterivNV_(stage, portion, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, IntPtr parameters)
+        {
+            GetFinalCombinerInputParameterfvNV_(variable, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, object parameters)
+
+        public static
+        void GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFinalCombinerInputParameterfvNV_(variable, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFinalCombinerInputParameterfvNV_(variable, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, IntPtr parameters)
+        {
+            GetFinalCombinerInputParameterivNV_(variable, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, object parameters)
+
+        public static
+        void GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFinalCombinerInputParameterivNV_(variable, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFinalCombinerInputParameterivNV_(variable, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2dvMESA(IntPtr v)
+
+        public static
+        void WindowPos2dvMESA(IntPtr v)
+        {
+            WindowPos2dvMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos2dvMESA(object v)
+
+        public static
+        void WindowPos2dvMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2dvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2dvMESA(GLdouble[] v)
+
+        public static
+        void WindowPos2dvMESA(GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2dvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2fvMESA(IntPtr v)
+
+        public static
+        void WindowPos2fvMESA(IntPtr v)
+        {
+            WindowPos2fvMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos2fvMESA(object v)
+
+        public static
+        void WindowPos2fvMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2fvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2fvMESA(GLfloat[] v)
+
+        public static
+        void WindowPos2fvMESA(GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2fvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2ivMESA(IntPtr v)
+
+        public static
+        void WindowPos2ivMESA(IntPtr v)
+        {
+            WindowPos2ivMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos2ivMESA(object v)
+
+        public static
+        void WindowPos2ivMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2ivMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2ivMESA(GLint[] v)
+
+        public static
+        void WindowPos2ivMESA(GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2ivMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2svMESA(IntPtr v)
+
+        public static
+        void WindowPos2svMESA(IntPtr v)
+        {
+            WindowPos2svMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos2svMESA(object v)
+
+        public static
+        void WindowPos2svMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2svMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos2svMESA(GLshort[] v)
+
+        public static
+        void WindowPos2svMESA(GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos2svMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3dvMESA(IntPtr v)
+
+        public static
+        void WindowPos3dvMESA(IntPtr v)
+        {
+            WindowPos3dvMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos3dvMESA(object v)
+
+        public static
+        void WindowPos3dvMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3dvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3dvMESA(GLdouble[] v)
+
+        public static
+        void WindowPos3dvMESA(GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3dvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3fvMESA(IntPtr v)
+
+        public static
+        void WindowPos3fvMESA(IntPtr v)
+        {
+            WindowPos3fvMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos3fvMESA(object v)
+
+        public static
+        void WindowPos3fvMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3fvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3fvMESA(GLfloat[] v)
+
+        public static
+        void WindowPos3fvMESA(GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3fvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3ivMESA(IntPtr v)
+
+        public static
+        void WindowPos3ivMESA(IntPtr v)
+        {
+            WindowPos3ivMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos3ivMESA(object v)
+
+        public static
+        void WindowPos3ivMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3ivMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3ivMESA(GLint[] v)
+
+        public static
+        void WindowPos3ivMESA(GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3ivMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3svMESA(IntPtr v)
+
+        public static
+        void WindowPos3svMESA(IntPtr v)
+        {
+            WindowPos3svMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos3svMESA(object v)
+
+        public static
+        void WindowPos3svMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3svMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos3svMESA(GLshort[] v)
+
+        public static
+        void WindowPos3svMESA(GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos3svMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos4dvMESA(IntPtr v)
+
+        public static
+        void WindowPos4dvMESA(IntPtr v)
+        {
+            WindowPos4dvMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos4dvMESA(object v)
+
+        public static
+        void WindowPos4dvMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos4dvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos4dvMESA(GLdouble[] v)
+
+        public static
+        void WindowPos4dvMESA(GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos4dvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos4fvMESA(IntPtr v)
+
+        public static
+        void WindowPos4fvMESA(IntPtr v)
+        {
+            WindowPos4fvMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos4fvMESA(object v)
+
+        public static
+        void WindowPos4fvMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos4fvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos4fvMESA(GLfloat[] v)
+
+        public static
+        void WindowPos4fvMESA(GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos4fvMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos4ivMESA(IntPtr v)
+
+        public static
+        void WindowPos4ivMESA(IntPtr v)
+        {
+            WindowPos4ivMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos4ivMESA(object v)
+
+        public static
+        void WindowPos4ivMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos4ivMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos4ivMESA(GLint[] v)
+
+        public static
+        void WindowPos4ivMESA(GLint[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos4ivMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos4svMESA(IntPtr v)
+
+        public static
+        void WindowPos4svMESA(IntPtr v)
+        {
+            WindowPos4svMESA_(v);
+        }
+
+        #endregion
+
+        #region WindowPos4svMESA(object v)
+
+        public static
+        void WindowPos4svMESA(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos4svMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region WindowPos4svMESA(GLshort[] v)
+
+        public static
+        void WindowPos4svMESA(GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                WindowPos4svMESA_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            MultiModeDrawArraysIBM_(mode, first, count, primcount, modestride);
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(mode, first, h0.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(mode, first, h0.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), count, primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, object first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, object first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), count, primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(IntPtr mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, count, primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, object first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, object first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(object mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(object mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, count, primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, object first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, IntPtr count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, object count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawArraysIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(IntPtr mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(IntPtr mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            MultiModeDrawElementsIBM_(mode, count, type, indices, primcount, modestride);
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(IntPtr mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(IntPtr mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(mode, count, type, h0.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(IntPtr mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(IntPtr mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(mode, h0.AddrOfPinnedObject(), type, indices, primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(IntPtr mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(IntPtr mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(IntPtr mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(IntPtr mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(mode, h0.AddrOfPinnedObject(), type, indices, primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(IntPtr mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(IntPtr mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(object mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(object mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), count, type, indices, primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(object mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(object mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), count, type, h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(object mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(object mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(object mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(object mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(object mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(object mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(object mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(object mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, IntPtr count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), count, type, indices, primcount, modestride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, IntPtr count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), count, type, h1.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, object count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, object count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+
+        public static
+        void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, GLenum type, object indices, GLsizei primcount, GLint modestride)
+        {
+            GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+            try
+            {
+                MultiModeDrawElementsIBM_(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
+            }
+            finally
+            {
+                h2.Free();
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+
+        public static
+        void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+        {
+            ColorPointerListIBM_(size, type, stride, pointer, ptrstride);
+        }
+
+        #endregion
+
+        #region ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, object pointer, GLint ptrstride)
+
+        public static
+        void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, object pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ColorPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+
+        public static
+        void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ColorPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, IntPtr pointer, GLint ptrstride)
+
+        public static
+        void SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, IntPtr pointer, GLint ptrstride)
+        {
+            SecondaryColorPointerListIBM_(size, type, stride, pointer, ptrstride);
+        }
+
+        #endregion
+
+        #region SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, object pointer, GLint ptrstride)
+
+        public static
+        void SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, object pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColorPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+
+        public static
+        void SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColorPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region EdgeFlagPointerListIBM(GLint stride, IntPtr pointer, GLint ptrstride)
+
+        public static
+        void EdgeFlagPointerListIBM(GLint stride, IntPtr pointer, GLint ptrstride)
+        {
+            EdgeFlagPointerListIBM_(stride, pointer, ptrstride);
+        }
+
+        #endregion
+
+        #region EdgeFlagPointerListIBM(GLint stride, object pointer, GLint ptrstride)
+
+        public static
+        void EdgeFlagPointerListIBM(GLint stride, object pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                EdgeFlagPointerListIBM_(stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region EdgeFlagPointerListIBM(GLint stride, GLboolean[] pointer, GLint ptrstride)
+
+        public static
+        void EdgeFlagPointerListIBM(GLint stride, GLboolean[] pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                EdgeFlagPointerListIBM_(stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoordPointerListIBM(GLenum type, GLint stride, IntPtr pointer, GLint ptrstride)
+
+        public static
+        void FogCoordPointerListIBM(GLenum type, GLint stride, IntPtr pointer, GLint ptrstride)
+        {
+            FogCoordPointerListIBM_(type, stride, pointer, ptrstride);
+        }
+
+        #endregion
+
+        #region FogCoordPointerListIBM(GLenum type, GLint stride, object pointer, GLint ptrstride)
+
+        public static
+        void FogCoordPointerListIBM(GLenum type, GLint stride, object pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                FogCoordPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoordPointerListIBM(GLenum type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+
+        public static
+        void FogCoordPointerListIBM(GLenum type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                FogCoordPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+
+        public static
+        void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+        {
+            IndexPointerListIBM_(type, stride, pointer, ptrstride);
+        }
+
+        #endregion
+
+        #region IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, object pointer, GLint ptrstride)
+
+        public static
+        void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, object pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                IndexPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+
+        public static
+        void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                IndexPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+
+        public static
+        void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+        {
+            NormalPointerListIBM_(type, stride, pointer, ptrstride);
+        }
+
+        #endregion
+
+        #region NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, object pointer, GLint ptrstride)
+
+        public static
+        void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, object pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                NormalPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+
+        public static
+        void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                NormalPointerListIBM_(type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+
+        public static
+        void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+        {
+            TexCoordPointerListIBM_(size, type, stride, pointer, ptrstride);
+        }
+
+        #endregion
+
+        #region TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, object pointer, GLint ptrstride)
+
+        public static
+        void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, object pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                TexCoordPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+
+        public static
+        void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                TexCoordPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+
+        public static
+        void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr pointer, GLint ptrstride)
+        {
+            VertexPointerListIBM_(size, type, stride, pointer, ptrstride);
+        }
+
+        #endregion
+
+        #region VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, object pointer, GLint ptrstride)
+
+        public static
+        void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, object pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+
+        public static
+        void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, IntPtr[] pointer, GLint ptrstride)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexPointerListIBM_(size, type, stride, h0.AddrOfPinnedObject(), ptrstride);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region IglooInterfaceSGIX(GLenum pname, IntPtr parameters)
+
+        public static
+        void IglooInterfaceSGIX(GLenum pname, IntPtr parameters)
+        {
+            IglooInterfaceSGIX_(pname, parameters);
+        }
+
+        #endregion
+
+        #region IglooInterfaceSGIX(GLenum pname, object parameters)
+
+        public static
+        void IglooInterfaceSGIX(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                IglooInterfaceSGIX_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteFencesNV(GLsizei n, IntPtr fences)
+
+        public static
+        void DeleteFencesNV(GLsizei n, IntPtr fences)
+        {
+            DeleteFencesNV_(n, fences);
+        }
+
+        #endregion
+
+        #region DeleteFencesNV(GLsizei n, object fences)
+
+        public static
+        void DeleteFencesNV(GLsizei n, object fences)
+        {
+            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+            try
+            {
+                DeleteFencesNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteFencesNV(GLsizei n, GLuint[] fences)
+
+        public static
+        void DeleteFencesNV(GLsizei n, GLuint[] fences)
+        {
+            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+            try
+            {
+                DeleteFencesNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenFencesNV(GLsizei n, IntPtr fences)
+
+        public static
+        void GenFencesNV(GLsizei n, IntPtr fences)
+        {
+            GenFencesNV_(n, fences);
+        }
+
+        #endregion
+
+        #region GenFencesNV(GLsizei n, object fences)
+
+        public static
+        void GenFencesNV(GLsizei n, object fences)
+        {
+            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+            try
+            {
+                GenFencesNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenFencesNV(GLsizei n, GLuint[] fences)
+
+        public static
+        void GenFencesNV(GLsizei n, GLuint[] fences)
+        {
+            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+            try
+            {
+                GenFencesNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFenceivNV(GLuint fence, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetFenceivNV(GLuint fence, GLenum pname, IntPtr parameters)
+        {
+            GetFenceivNV_(fence, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetFenceivNV(GLuint fence, GLenum pname, object parameters)
+
+        public static
+        void GetFenceivNV(GLuint fence, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFenceivNV_(fence, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFenceivNV(GLuint fence, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetFenceivNV(GLuint fence, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFenceivNV_(fence, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, Enums.Boolean packed, IntPtr points)
+
+        public static
+        void MapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, Enums.Boolean packed, IntPtr points)
+        {
+            MapControlPointsNV_(target, index, type, ustride, vstride, uorder, vorder, packed, points);
+        }
+
+        #endregion
+
+        #region MapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, Enums.Boolean packed, object points)
+
+        public static
+        void MapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, Enums.Boolean packed, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                MapControlPointsNV_(target, index, type, ustride, vstride, uorder, vorder, packed, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MapParameterivNV(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void MapParameterivNV(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            MapParameterivNV_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region MapParameterivNV(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void MapParameterivNV(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                MapParameterivNV_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MapParameterivNV(GLenum target, GLenum pname, GLint[] parameters)
+
+        public static
+        void MapParameterivNV(GLenum target, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                MapParameterivNV_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MapParameterfvNV(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void MapParameterfvNV(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            MapParameterfvNV_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region MapParameterfvNV(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void MapParameterfvNV(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                MapParameterfvNV_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MapParameterfvNV(GLenum target, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void MapParameterfvNV(GLenum target, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                MapParameterfvNV_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, Enums.Boolean packed, IntPtr points)
+
+        public static
+        void GetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, Enums.Boolean packed, IntPtr points)
+        {
+            GetMapControlPointsNV_(target, index, type, ustride, vstride, packed, points);
+        }
+
+        #endregion
+
+        #region GetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, Enums.Boolean packed, object points)
+
+        public static
+        void GetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, Enums.Boolean packed, object points)
+        {
+            GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+            try
+            {
+                GetMapControlPointsNV_(target, index, type, ustride, vstride, packed, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapParameterivNV(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetMapParameterivNV(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetMapParameterivNV_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetMapParameterivNV(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetMapParameterivNV(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMapParameterivNV_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapParameterivNV(GLenum target, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetMapParameterivNV(GLenum target, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMapParameterivNV_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapParameterfvNV(GLenum target, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetMapParameterfvNV(GLenum target, GLenum pname, IntPtr parameters)
+        {
+            GetMapParameterfvNV_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetMapParameterfvNV(GLenum target, GLenum pname, object parameters)
+
+        public static
+        void GetMapParameterfvNV(GLenum target, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMapParameterfvNV_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapParameterfvNV(GLenum target, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetMapParameterfvNV(GLenum target, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMapParameterfvNV_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetMapAttribParameterivNV_(target, index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMapAttribParameterivNV_(target, index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMapAttribParameterivNV_(target, index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetMapAttribParameterfvNV_(target, index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMapAttribParameterfvNV_(target, index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetMapAttribParameterfvNV_(target, index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CombinerStageParameterfvNV(GLenum stage, GLenum pname, IntPtr parameters)
+
+        public static
+        void CombinerStageParameterfvNV(GLenum stage, GLenum pname, IntPtr parameters)
+        {
+            CombinerStageParameterfvNV_(stage, pname, parameters);
+        }
+
+        #endregion
+
+        #region CombinerStageParameterfvNV(GLenum stage, GLenum pname, object parameters)
+
+        public static
+        void CombinerStageParameterfvNV(GLenum stage, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CombinerStageParameterfvNV_(stage, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region CombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void CombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                CombinerStageParameterfvNV_(stage, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, IntPtr parameters)
+        {
+            GetCombinerStageParameterfvNV_(stage, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, object parameters)
+
+        public static
+        void GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerStageParameterfvNV_(stage, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetCombinerStageParameterfvNV_(stage, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, IntPtr programs, IntPtr residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, IntPtr programs, IntPtr residences)
+        {
+            return AreProgramsResidentNV_(n, programs, residences);
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, IntPtr programs, object residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, IntPtr programs, object residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreProgramsResidentNV_(n, programs, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, IntPtr programs, Enums.Boolean[] residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, IntPtr programs, Enums.Boolean[] residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreProgramsResidentNV_(n, programs, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, object programs, IntPtr residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, object programs, IntPtr residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), residences);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, object programs, object residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, object programs, object residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, object programs, Enums.Boolean[] residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, object programs, Enums.Boolean[] residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, GLuint[] programs, IntPtr residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, IntPtr residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), residences);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, GLuint[] programs, object residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, object residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region AreProgramsResidentNV(GLsizei n, GLuint[] programs, Enums.Boolean[] residences)
+
+        public static
+        GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, Enums.Boolean[] residences)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+            try
+            {
+                return AreProgramsResidentNV_(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteProgramsNV(GLsizei n, IntPtr programs)
+
+        public static
+        void DeleteProgramsNV(GLsizei n, IntPtr programs)
+        {
+            DeleteProgramsNV_(n, programs);
+        }
+
+        #endregion
+
+        #region DeleteProgramsNV(GLsizei n, object programs)
+
+        public static
+        void DeleteProgramsNV(GLsizei n, object programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                DeleteProgramsNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteProgramsNV(GLsizei n, GLuint[] programs)
+
+        public static
+        void DeleteProgramsNV(GLsizei n, GLuint[] programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                DeleteProgramsNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ExecuteProgramNV(GLenum target, GLuint id, IntPtr parameters)
+
+        public static
+        void ExecuteProgramNV(GLenum target, GLuint id, IntPtr parameters)
+        {
+            ExecuteProgramNV_(target, id, parameters);
+        }
+
+        #endregion
+
+        #region ExecuteProgramNV(GLenum target, GLuint id, object parameters)
+
+        public static
+        void ExecuteProgramNV(GLenum target, GLuint id, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ExecuteProgramNV_(target, id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ExecuteProgramNV(GLenum target, GLuint id, GLfloat[] parameters)
+
+        public static
+        void ExecuteProgramNV(GLenum target, GLuint id, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ExecuteProgramNV_(target, id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenProgramsNV(GLsizei n, IntPtr programs)
+
+        public static
+        void GenProgramsNV(GLsizei n, IntPtr programs)
+        {
+            GenProgramsNV_(n, programs);
+        }
+
+        #endregion
+
+        #region GenProgramsNV(GLsizei n, object programs)
+
+        public static
+        void GenProgramsNV(GLsizei n, object programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                GenProgramsNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenProgramsNV(GLsizei n, GLuint[] programs)
+
+        public static
+        void GenProgramsNV(GLsizei n, GLuint[] programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                GenProgramsNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetProgramParameterdvNV_(target, index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramParameterdvNV_(target, index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble[] parameters)
+
+        public static
+        void GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramParameterdvNV_(target, index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetProgramParameterfvNV_(target, index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramParameterfvNV_(target, index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramParameterfvNV_(target, index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramivNV(GLuint id, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetProgramivNV(GLuint id, GLenum pname, IntPtr parameters)
+        {
+            GetProgramivNV_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramivNV(GLuint id, GLenum pname, object parameters)
+
+        public static
+        void GetProgramivNV(GLuint id, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramivNV_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramivNV(GLuint id, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetProgramivNV(GLuint id, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramivNV_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramStringNV(GLuint id, GLenum pname, IntPtr program)
+
+        public static
+        void GetProgramStringNV(GLuint id, GLenum pname, IntPtr program)
+        {
+            GetProgramStringNV_(id, pname, program);
+        }
+
+        #endregion
+
+        #region GetProgramStringNV(GLuint id, GLenum pname, object program)
+
+        public static
+        void GetProgramStringNV(GLuint id, GLenum pname, object program)
+        {
+            GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
+            try
+            {
+                GetProgramStringNV_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramStringNV(GLuint id, GLenum pname, GLubyte[] program)
+
+        public static
+        void GetProgramStringNV(GLuint id, GLenum pname, GLubyte[] program)
+        {
+            GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
+            try
+            {
+                GetProgramStringNV_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, IntPtr parameters)
+        {
+            GetTrackMatrixivNV_(target, address, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, object parameters)
+
+        public static
+        void GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetTrackMatrixivNV_(target, address, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetTrackMatrixivNV_(target, address, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribdvNV(GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVertexAttribdvNV(GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetVertexAttribdvNV_(index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVertexAttribdvNV(GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetVertexAttribdvNV(GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribdvNV_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble[] parameters)
+
+        public static
+        void GetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribdvNV_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribfvNV(GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVertexAttribfvNV(GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetVertexAttribfvNV_(index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVertexAttribfvNV(GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetVertexAttribfvNV(GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribfvNV_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribfvNV_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribivNV(GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVertexAttribivNV(GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetVertexAttribivNV_(index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVertexAttribivNV(GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetVertexAttribivNV(GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribivNV_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribivNV(GLuint index, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetVertexAttribivNV(GLuint index, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribivNV_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribPointervNV(GLuint index, GLenum pname, IntPtr pointer)
+
+        public static
+        void GetVertexAttribPointervNV(GLuint index, GLenum pname, IntPtr pointer)
+        {
+            GetVertexAttribPointervNV_(index, pname, pointer);
+        }
+
+        #endregion
+
+        #region GetVertexAttribPointervNV(GLuint index, GLenum pname, object pointer)
+
+        public static
+        void GetVertexAttribPointervNV(GLuint index, GLenum pname, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribPointervNV_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribPointervNV(GLuint index, GLenum pname, IntPtr[] pointer)
+
+        public static
+        void GetVertexAttribPointervNV(GLuint index, GLenum pname, IntPtr[] pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribPointervNV_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region LoadProgramNV(GLenum target, GLuint id, GLsizei len, IntPtr program)
+
+        public static
+        void LoadProgramNV(GLenum target, GLuint id, GLsizei len, IntPtr program)
+        {
+            LoadProgramNV_(target, id, len, program);
+        }
+
+        #endregion
+
+        #region LoadProgramNV(GLenum target, GLuint id, GLsizei len, object program)
+
+        public static
+        void LoadProgramNV(GLenum target, GLuint id, GLsizei len, object program)
+        {
+            GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
+            try
+            {
+                LoadProgramNV_(target, id, len, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region LoadProgramNV(GLenum target, GLuint id, GLsizei len, GLubyte[] program)
+
+        public static
+        void LoadProgramNV(GLenum target, GLuint id, GLsizei len, GLubyte[] program)
+        {
+            GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
+            try
+            {
+                LoadProgramNV_(target, id, len, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramParameter4dvNV(GLenum target, GLuint index, IntPtr v)
+
+        public static
+        void ProgramParameter4dvNV(GLenum target, GLuint index, IntPtr v)
+        {
+            ProgramParameter4dvNV_(target, index, v);
+        }
+
+        #endregion
+
+        #region ProgramParameter4dvNV(GLenum target, GLuint index, object v)
+
+        public static
+        void ProgramParameter4dvNV(GLenum target, GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramParameter4dvNV_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramParameter4dvNV(GLenum target, GLuint index, GLdouble[] v)
+
+        public static
+        void ProgramParameter4dvNV(GLenum target, GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramParameter4dvNV_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramParameter4fvNV(GLenum target, GLuint index, IntPtr v)
+
+        public static
+        void ProgramParameter4fvNV(GLenum target, GLuint index, IntPtr v)
+        {
+            ProgramParameter4fvNV_(target, index, v);
+        }
+
+        #endregion
+
+        #region ProgramParameter4fvNV(GLenum target, GLuint index, object v)
+
+        public static
+        void ProgramParameter4fvNV(GLenum target, GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramParameter4fvNV_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramParameter4fvNV(GLenum target, GLuint index, GLfloat[] v)
+
+        public static
+        void ProgramParameter4fvNV(GLenum target, GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramParameter4fvNV_(target, index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, IntPtr v)
+
+        public static
+        void ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, IntPtr v)
+        {
+            ProgramParameters4dvNV_(target, index, count, v);
+        }
+
+        #endregion
+
+        #region ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, object v)
+
+        public static
+        void ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramParameters4dvNV_(target, index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, GLdouble[] v)
+
+        public static
+        void ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramParameters4dvNV_(target, index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, IntPtr v)
+
+        public static
+        void ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, IntPtr v)
+        {
+            ProgramParameters4fvNV_(target, index, count, v);
+        }
+
+        #endregion
+
+        #region ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, object v)
+
+        public static
+        void ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramParameters4fvNV_(target, index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, GLfloat[] v)
+
+        public static
+        void ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramParameters4fvNV_(target, index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region RequestResidentProgramsNV(GLsizei n, IntPtr programs)
+
+        public static
+        void RequestResidentProgramsNV(GLsizei n, IntPtr programs)
+        {
+            RequestResidentProgramsNV_(n, programs);
+        }
+
+        #endregion
+
+        #region RequestResidentProgramsNV(GLsizei n, object programs)
+
+        public static
+        void RequestResidentProgramsNV(GLsizei n, object programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                RequestResidentProgramsNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region RequestResidentProgramsNV(GLsizei n, GLuint[] programs)
+
+        public static
+        void RequestResidentProgramsNV(GLsizei n, GLuint[] programs)
+        {
+            GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+            try
+            {
+                RequestResidentProgramsNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, IntPtr pointer)
+
+        public static
+        void VertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, IntPtr pointer)
+        {
+            VertexAttribPointerNV_(index, fsize, type, stride, pointer);
+        }
+
+        #endregion
+
+        #region VertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, object pointer)
+
+        public static
+        void VertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribPointerNV_(index, fsize, type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1dvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib1dvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib1dvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib1dvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib1dvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1dvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1dvNV(GLuint index, GLdouble[] v)
+
+        public static
+        void VertexAttrib1dvNV(GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1dvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1fvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib1fvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib1fvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib1fvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib1fvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1fvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1fvNV(GLuint index, GLfloat[] v)
+
+        public static
+        void VertexAttrib1fvNV(GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1fvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1svNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib1svNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib1svNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib1svNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib1svNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1svNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1svNV(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib1svNV(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1svNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2dvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib2dvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib2dvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib2dvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib2dvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2dvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2dvNV(GLuint index, GLdouble[] v)
+
+        public static
+        void VertexAttrib2dvNV(GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2dvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2fvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib2fvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib2fvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib2fvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib2fvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2fvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2fvNV(GLuint index, GLfloat[] v)
+
+        public static
+        void VertexAttrib2fvNV(GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2fvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2svNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib2svNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib2svNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib2svNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib2svNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2svNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2svNV(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib2svNV(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2svNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3dvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib3dvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib3dvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib3dvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib3dvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3dvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3dvNV(GLuint index, GLdouble[] v)
+
+        public static
+        void VertexAttrib3dvNV(GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3dvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3fvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib3fvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib3fvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib3fvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib3fvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3fvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3fvNV(GLuint index, GLfloat[] v)
+
+        public static
+        void VertexAttrib3fvNV(GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3fvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3svNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib3svNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib3svNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib3svNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib3svNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3svNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3svNV(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib3svNV(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3svNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4dvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4dvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib4dvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4dvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib4dvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4dvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4dvNV(GLuint index, GLdouble[] v)
+
+        public static
+        void VertexAttrib4dvNV(GLuint index, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4dvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4fvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4fvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib4fvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4fvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib4fvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4fvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4fvNV(GLuint index, GLfloat[] v)
+
+        public static
+        void VertexAttrib4fvNV(GLuint index, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4fvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4svNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4svNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib4svNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4svNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib4svNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4svNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4svNV(GLuint index, GLshort[] v)
+
+        public static
+        void VertexAttrib4svNV(GLuint index, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4svNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4ubvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4ubvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib4ubvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4ubvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib4ubvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4ubvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4ubvNV(GLuint index, GLubyte[] v)
+
+        public static
+        void VertexAttrib4ubvNV(GLuint index, GLubyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4ubvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs1dvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs1dvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs1dvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs1dvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs1dvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs1dvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs1dvNV(GLuint index, GLsizei count, GLdouble[] v)
+
+        public static
+        void VertexAttribs1dvNV(GLuint index, GLsizei count, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs1dvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs1fvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs1fvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs1fvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs1fvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs1fvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs1fvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs1fvNV(GLuint index, GLsizei count, GLfloat[] v)
+
+        public static
+        void VertexAttribs1fvNV(GLuint index, GLsizei count, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs1fvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs1svNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs1svNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs1svNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs1svNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs1svNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs1svNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs1svNV(GLuint index, GLsizei count, GLshort[] v)
+
+        public static
+        void VertexAttribs1svNV(GLuint index, GLsizei count, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs1svNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs2dvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs2dvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs2dvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs2dvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs2dvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs2dvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs2dvNV(GLuint index, GLsizei count, GLdouble[] v)
+
+        public static
+        void VertexAttribs2dvNV(GLuint index, GLsizei count, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs2dvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs2fvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs2fvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs2fvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs2fvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs2fvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs2fvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs2fvNV(GLuint index, GLsizei count, GLfloat[] v)
+
+        public static
+        void VertexAttribs2fvNV(GLuint index, GLsizei count, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs2fvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs2svNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs2svNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs2svNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs2svNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs2svNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs2svNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs2svNV(GLuint index, GLsizei count, GLshort[] v)
+
+        public static
+        void VertexAttribs2svNV(GLuint index, GLsizei count, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs2svNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs3dvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs3dvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs3dvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs3dvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs3dvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs3dvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs3dvNV(GLuint index, GLsizei count, GLdouble[] v)
+
+        public static
+        void VertexAttribs3dvNV(GLuint index, GLsizei count, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs3dvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs3fvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs3fvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs3fvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs3fvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs3fvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs3fvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs3fvNV(GLuint index, GLsizei count, GLfloat[] v)
+
+        public static
+        void VertexAttribs3fvNV(GLuint index, GLsizei count, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs3fvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs3svNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs3svNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs3svNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs3svNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs3svNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs3svNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs3svNV(GLuint index, GLsizei count, GLshort[] v)
+
+        public static
+        void VertexAttribs3svNV(GLuint index, GLsizei count, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs3svNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4dvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs4dvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs4dvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs4dvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs4dvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4dvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4dvNV(GLuint index, GLsizei count, GLdouble[] v)
+
+        public static
+        void VertexAttribs4dvNV(GLuint index, GLsizei count, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4dvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4fvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs4fvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs4fvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs4fvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs4fvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4fvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4fvNV(GLuint index, GLsizei count, GLfloat[] v)
+
+        public static
+        void VertexAttribs4fvNV(GLuint index, GLsizei count, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4fvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4svNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs4svNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs4svNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs4svNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs4svNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4svNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4svNV(GLuint index, GLsizei count, GLshort[] v)
+
+        public static
+        void VertexAttribs4svNV(GLuint index, GLsizei count, GLshort[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4svNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4ubvNV(GLuint index, GLsizei count, IntPtr v)
+
+        public static
+        void VertexAttribs4ubvNV(GLuint index, GLsizei count, IntPtr v)
+        {
+            VertexAttribs4ubvNV_(index, count, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs4ubvNV(GLuint index, GLsizei count, object v)
+
+        public static
+        void VertexAttribs4ubvNV(GLuint index, GLsizei count, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4ubvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4ubvNV(GLuint index, GLsizei count, GLubyte[] v)
+
+        public static
+        void VertexAttribs4ubvNV(GLuint index, GLsizei count, GLubyte[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4ubvNV_(index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexBumpParameterivATI(GLenum pname, IntPtr param)
+
+        public static
+        void TexBumpParameterivATI(GLenum pname, IntPtr param)
+        {
+            TexBumpParameterivATI_(pname, param);
+        }
+
+        #endregion
+
+        #region TexBumpParameterivATI(GLenum pname, object param)
+
+        public static
+        void TexBumpParameterivATI(GLenum pname, object param)
+        {
+            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+            try
+            {
+                TexBumpParameterivATI_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexBumpParameterivATI(GLenum pname, GLint[] param)
+
+        public static
+        void TexBumpParameterivATI(GLenum pname, GLint[] param)
+        {
+            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+            try
+            {
+                TexBumpParameterivATI_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexBumpParameterfvATI(GLenum pname, IntPtr param)
+
+        public static
+        void TexBumpParameterfvATI(GLenum pname, IntPtr param)
+        {
+            TexBumpParameterfvATI_(pname, param);
+        }
+
+        #endregion
+
+        #region TexBumpParameterfvATI(GLenum pname, object param)
+
+        public static
+        void TexBumpParameterfvATI(GLenum pname, object param)
+        {
+            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+            try
+            {
+                TexBumpParameterfvATI_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexBumpParameterfvATI(GLenum pname, GLfloat[] param)
+
+        public static
+        void TexBumpParameterfvATI(GLenum pname, GLfloat[] param)
+        {
+            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+            try
+            {
+                TexBumpParameterfvATI_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetTexBumpParameterivATI(GLenum pname, IntPtr param)
+
+        public static
+        void GetTexBumpParameterivATI(GLenum pname, IntPtr param)
+        {
+            GetTexBumpParameterivATI_(pname, param);
+        }
+
+        #endregion
+
+        #region GetTexBumpParameterivATI(GLenum pname, object param)
+
+        public static
+        void GetTexBumpParameterivATI(GLenum pname, object param)
+        {
+            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+            try
+            {
+                GetTexBumpParameterivATI_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetTexBumpParameterivATI(GLenum pname, GLint[] param)
+
+        public static
+        void GetTexBumpParameterivATI(GLenum pname, GLint[] param)
+        {
+            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+            try
+            {
+                GetTexBumpParameterivATI_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetTexBumpParameterfvATI(GLenum pname, IntPtr param)
+
+        public static
+        void GetTexBumpParameterfvATI(GLenum pname, IntPtr param)
+        {
+            GetTexBumpParameterfvATI_(pname, param);
+        }
+
+        #endregion
+
+        #region GetTexBumpParameterfvATI(GLenum pname, object param)
+
+        public static
+        void GetTexBumpParameterfvATI(GLenum pname, object param)
+        {
+            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+            try
+            {
+                GetTexBumpParameterfvATI_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetTexBumpParameterfvATI(GLenum pname, GLfloat[] param)
+
+        public static
+        void GetTexBumpParameterfvATI(GLenum pname, GLfloat[] param)
+        {
+            GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+            try
+            {
+                GetTexBumpParameterfvATI_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SetFragmentShaderConstantATI(GLuint dst, IntPtr value)
+
+        public static
+        void SetFragmentShaderConstantATI(GLuint dst, IntPtr value)
+        {
+            SetFragmentShaderConstantATI_(dst, value);
+        }
+
+        #endregion
+
+        #region SetFragmentShaderConstantATI(GLuint dst, object value)
+
+        public static
+        void SetFragmentShaderConstantATI(GLuint dst, object value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                SetFragmentShaderConstantATI_(dst, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SetFragmentShaderConstantATI(GLuint dst, GLfloat[] value)
+
+        public static
+        void SetFragmentShaderConstantATI(GLuint dst, GLfloat[] value)
+        {
+            GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+            try
+            {
+                SetFragmentShaderConstantATI_(dst, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NewObjectBufferATI(GLsizei size, IntPtr pointer, GLenum usage)
+
+        public static
+        GLuint NewObjectBufferATI(GLsizei size, IntPtr pointer, GLenum usage)
+        {
+            return NewObjectBufferATI_(size, pointer, usage);
+        }
+
+        #endregion
+
+        #region NewObjectBufferATI(GLsizei size, object pointer, GLenum usage)
+
+        public static
+        GLuint NewObjectBufferATI(GLsizei size, object pointer, GLenum usage)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                return NewObjectBufferATI_(size, h0.AddrOfPinnedObject(), usage);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, IntPtr pointer, GLenum preserve)
+
+        public static
+        void UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, IntPtr pointer, GLenum preserve)
+        {
+            UpdateObjectBufferATI_(buffer, offset, size, pointer, preserve);
+        }
+
+        #endregion
+
+        #region UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, object pointer, GLenum preserve)
+
+        public static
+        void UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, object pointer, GLenum preserve)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                UpdateObjectBufferATI_(buffer, offset, size, h0.AddrOfPinnedObject(), preserve);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetObjectBufferfvATI(GLuint buffer, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetObjectBufferfvATI(GLuint buffer, GLenum pname, IntPtr parameters)
+        {
+            GetObjectBufferfvATI_(buffer, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetObjectBufferfvATI(GLuint buffer, GLenum pname, object parameters)
+
+        public static
+        void GetObjectBufferfvATI(GLuint buffer, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetObjectBufferfvATI_(buffer, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetObjectBufferfvATI_(buffer, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetObjectBufferivATI(GLuint buffer, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetObjectBufferivATI(GLuint buffer, GLenum pname, IntPtr parameters)
+        {
+            GetObjectBufferivATI_(buffer, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetObjectBufferivATI(GLuint buffer, GLenum pname, object parameters)
+
+        public static
+        void GetObjectBufferivATI(GLuint buffer, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetObjectBufferivATI_(buffer, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetObjectBufferivATI(GLuint buffer, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetObjectBufferivATI(GLuint buffer, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetObjectBufferivATI_(buffer, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, IntPtr parameters)
+        {
+            GetArrayObjectfvATI_(array, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, object parameters)
+
+        public static
+        void GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetArrayObjectfvATI_(array, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetArrayObjectfvATI_(array, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, IntPtr parameters)
+        {
+            GetArrayObjectivATI_(array, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, object parameters)
+
+        public static
+        void GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetArrayObjectivATI_(array, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetArrayObjectivATI_(array, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantArrayObjectfvATI(GLuint id, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVariantArrayObjectfvATI(GLuint id, GLenum pname, IntPtr parameters)
+        {
+            GetVariantArrayObjectfvATI_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVariantArrayObjectfvATI(GLuint id, GLenum pname, object parameters)
+
+        public static
+        void GetVariantArrayObjectfvATI(GLuint id, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVariantArrayObjectfvATI_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVariantArrayObjectfvATI_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantArrayObjectivATI(GLuint id, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVariantArrayObjectivATI(GLuint id, GLenum pname, IntPtr parameters)
+        {
+            GetVariantArrayObjectivATI_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVariantArrayObjectivATI(GLuint id, GLenum pname, object parameters)
+
+        public static
+        void GetVariantArrayObjectivATI(GLuint id, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVariantArrayObjectivATI_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVariantArrayObjectivATI_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SetInvariantEXT(GLuint id, GLenum type, IntPtr addr)
+
+        public static
+        void SetInvariantEXT(GLuint id, GLenum type, IntPtr addr)
+        {
+            SetInvariantEXT_(id, type, addr);
+        }
+
+        #endregion
+
+        #region SetInvariantEXT(GLuint id, GLenum type, object addr)
+
+        public static
+        void SetInvariantEXT(GLuint id, GLenum type, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                SetInvariantEXT_(id, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SetLocalConstantEXT(GLuint id, GLenum type, IntPtr addr)
+
+        public static
+        void SetLocalConstantEXT(GLuint id, GLenum type, IntPtr addr)
+        {
+            SetLocalConstantEXT_(id, type, addr);
+        }
+
+        #endregion
+
+        #region SetLocalConstantEXT(GLuint id, GLenum type, object addr)
+
+        public static
+        void SetLocalConstantEXT(GLuint id, GLenum type, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                SetLocalConstantEXT_(id, type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantbvEXT(GLuint id, IntPtr addr)
+
+        public static
+        void VariantbvEXT(GLuint id, IntPtr addr)
+        {
+            VariantbvEXT_(id, addr);
+        }
+
+        #endregion
+
+        #region VariantbvEXT(GLuint id, object addr)
+
+        public static
+        void VariantbvEXT(GLuint id, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantbvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantbvEXT(GLuint id, GLbyte[] addr)
+
+        public static
+        void VariantbvEXT(GLuint id, GLbyte[] addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantbvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantsvEXT(GLuint id, IntPtr addr)
+
+        public static
+        void VariantsvEXT(GLuint id, IntPtr addr)
+        {
+            VariantsvEXT_(id, addr);
+        }
+
+        #endregion
+
+        #region VariantsvEXT(GLuint id, object addr)
+
+        public static
+        void VariantsvEXT(GLuint id, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantsvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantsvEXT(GLuint id, GLshort[] addr)
+
+        public static
+        void VariantsvEXT(GLuint id, GLshort[] addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantsvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantivEXT(GLuint id, IntPtr addr)
+
+        public static
+        void VariantivEXT(GLuint id, IntPtr addr)
+        {
+            VariantivEXT_(id, addr);
+        }
+
+        #endregion
+
+        #region VariantivEXT(GLuint id, object addr)
+
+        public static
+        void VariantivEXT(GLuint id, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantivEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantivEXT(GLuint id, GLint[] addr)
+
+        public static
+        void VariantivEXT(GLuint id, GLint[] addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantivEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantfvEXT(GLuint id, IntPtr addr)
+
+        public static
+        void VariantfvEXT(GLuint id, IntPtr addr)
+        {
+            VariantfvEXT_(id, addr);
+        }
+
+        #endregion
+
+        #region VariantfvEXT(GLuint id, object addr)
+
+        public static
+        void VariantfvEXT(GLuint id, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantfvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantfvEXT(GLuint id, GLfloat[] addr)
+
+        public static
+        void VariantfvEXT(GLuint id, GLfloat[] addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantfvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantdvEXT(GLuint id, IntPtr addr)
+
+        public static
+        void VariantdvEXT(GLuint id, IntPtr addr)
+        {
+            VariantdvEXT_(id, addr);
+        }
+
+        #endregion
+
+        #region VariantdvEXT(GLuint id, object addr)
+
+        public static
+        void VariantdvEXT(GLuint id, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantdvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantdvEXT(GLuint id, GLdouble[] addr)
+
+        public static
+        void VariantdvEXT(GLuint id, GLdouble[] addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantdvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantubvEXT(GLuint id, IntPtr addr)
+
+        public static
+        void VariantubvEXT(GLuint id, IntPtr addr)
+        {
+            VariantubvEXT_(id, addr);
+        }
+
+        #endregion
+
+        #region VariantubvEXT(GLuint id, object addr)
+
+        public static
+        void VariantubvEXT(GLuint id, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantubvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantubvEXT(GLuint id, GLubyte[] addr)
+
+        public static
+        void VariantubvEXT(GLuint id, GLubyte[] addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantubvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantusvEXT(GLuint id, IntPtr addr)
+
+        public static
+        void VariantusvEXT(GLuint id, IntPtr addr)
+        {
+            VariantusvEXT_(id, addr);
+        }
+
+        #endregion
+
+        #region VariantusvEXT(GLuint id, object addr)
+
+        public static
+        void VariantusvEXT(GLuint id, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantusvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantusvEXT(GLuint id, GLushort[] addr)
+
+        public static
+        void VariantusvEXT(GLuint id, GLushort[] addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantusvEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantuivEXT(GLuint id, IntPtr addr)
+
+        public static
+        void VariantuivEXT(GLuint id, IntPtr addr)
+        {
+            VariantuivEXT_(id, addr);
+        }
+
+        #endregion
+
+        #region VariantuivEXT(GLuint id, object addr)
+
+        public static
+        void VariantuivEXT(GLuint id, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantuivEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantuivEXT(GLuint id, GLuint[] addr)
+
+        public static
+        void VariantuivEXT(GLuint id, GLuint[] addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantuivEXT_(id, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VariantPointerEXT(GLuint id, GLenum type, GLuint stride, IntPtr addr)
+
+        public static
+        void VariantPointerEXT(GLuint id, GLenum type, GLuint stride, IntPtr addr)
+        {
+            VariantPointerEXT_(id, type, stride, addr);
+        }
+
+        #endregion
+
+        #region VariantPointerEXT(GLuint id, GLenum type, GLuint stride, object addr)
+
+        public static
+        void VariantPointerEXT(GLuint id, GLenum type, GLuint stride, object addr)
+        {
+            GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+            try
+            {
+                VariantPointerEXT_(id, type, stride, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetVariantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetVariantBooleanvEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetVariantBooleanvEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetVariantBooleanvEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetVariantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data)
+
+        public static
+        void GetVariantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetVariantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantIntegervEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetVariantIntegervEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetVariantIntegervEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetVariantIntegervEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetVariantIntegervEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetVariantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantIntegervEXT(GLuint id, GLenum value, GLint[] data)
+
+        public static
+        void GetVariantIntegervEXT(GLuint id, GLenum value, GLint[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetVariantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantFloatvEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetVariantFloatvEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetVariantFloatvEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetVariantFloatvEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetVariantFloatvEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetVariantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
+
+        public static
+        void GetVariantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetVariantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantPointervEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetVariantPointervEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetVariantPointervEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetVariantPointervEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetVariantPointervEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetVariantPointervEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVariantPointervEXT(GLuint id, GLenum value, IntPtr[] data)
+
+        public static
+        void GetVariantPointervEXT(GLuint id, GLenum value, IntPtr[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetVariantPointervEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetInvariantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetInvariantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetInvariantBooleanvEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetInvariantBooleanvEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetInvariantBooleanvEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetInvariantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetInvariantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data)
+
+        public static
+        void GetInvariantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetInvariantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetInvariantIntegervEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetInvariantIntegervEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetInvariantIntegervEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetInvariantIntegervEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetInvariantIntegervEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetInvariantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetInvariantIntegervEXT(GLuint id, GLenum value, GLint[] data)
+
+        public static
+        void GetInvariantIntegervEXT(GLuint id, GLenum value, GLint[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetInvariantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetInvariantFloatvEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetInvariantFloatvEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetInvariantFloatvEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetInvariantFloatvEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetInvariantFloatvEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetInvariantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
+
+        public static
+        void GetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetInvariantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetLocalConstantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetLocalConstantBooleanvEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetLocalConstantBooleanvEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetLocalConstantBooleanvEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetLocalConstantBooleanvEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetLocalConstantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetLocalConstantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data)
+
+        public static
+        void GetLocalConstantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetLocalConstantBooleanvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetLocalConstantIntegervEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetLocalConstantIntegervEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetLocalConstantIntegervEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetLocalConstantIntegervEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetLocalConstantIntegervEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetLocalConstantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint[] data)
+
+        public static
+        void GetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetLocalConstantIntegervEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetLocalConstantFloatvEXT(GLuint id, GLenum value, IntPtr data)
+
+        public static
+        void GetLocalConstantFloatvEXT(GLuint id, GLenum value, IntPtr data)
+        {
+            GetLocalConstantFloatvEXT_(id, value, data);
+        }
+
+        #endregion
+
+        #region GetLocalConstantFloatvEXT(GLuint id, GLenum value, object data)
+
+        public static
+        void GetLocalConstantFloatvEXT(GLuint id, GLenum value, object data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetLocalConstantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
+
+        public static
+        void GetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat[] data)
+        {
+            GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+            try
+            {
+                GetLocalConstantFloatvEXT_(id, value, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream1svATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream1svATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream1svATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream1svATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream1svATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream1svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream1svATI(GLenum stream, GLshort[] coords)
+
+        public static
+        void VertexStream1svATI(GLenum stream, GLshort[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream1svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream1ivATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream1ivATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream1ivATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream1ivATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream1ivATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream1ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream1ivATI(GLenum stream, GLint[] coords)
+
+        public static
+        void VertexStream1ivATI(GLenum stream, GLint[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream1ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream1fvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream1fvATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream1fvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream1fvATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream1fvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream1fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream1fvATI(GLenum stream, GLfloat[] coords)
+
+        public static
+        void VertexStream1fvATI(GLenum stream, GLfloat[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream1fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream1dvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream1dvATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream1dvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream1dvATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream1dvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream1dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream1dvATI(GLenum stream, GLdouble[] coords)
+
+        public static
+        void VertexStream1dvATI(GLenum stream, GLdouble[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream1dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream2svATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream2svATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream2svATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream2svATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream2svATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream2svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream2svATI(GLenum stream, GLshort[] coords)
+
+        public static
+        void VertexStream2svATI(GLenum stream, GLshort[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream2svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream2ivATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream2ivATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream2ivATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream2ivATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream2ivATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream2ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream2ivATI(GLenum stream, GLint[] coords)
+
+        public static
+        void VertexStream2ivATI(GLenum stream, GLint[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream2ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream2fvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream2fvATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream2fvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream2fvATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream2fvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream2fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream2fvATI(GLenum stream, GLfloat[] coords)
+
+        public static
+        void VertexStream2fvATI(GLenum stream, GLfloat[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream2fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream2dvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream2dvATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream2dvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream2dvATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream2dvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream2dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream2dvATI(GLenum stream, GLdouble[] coords)
+
+        public static
+        void VertexStream2dvATI(GLenum stream, GLdouble[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream2dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream3svATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream3svATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream3svATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream3svATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream3svATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream3svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream3svATI(GLenum stream, GLshort[] coords)
+
+        public static
+        void VertexStream3svATI(GLenum stream, GLshort[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream3svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream3ivATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream3ivATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream3ivATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream3ivATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream3ivATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream3ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream3ivATI(GLenum stream, GLint[] coords)
+
+        public static
+        void VertexStream3ivATI(GLenum stream, GLint[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream3ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream3fvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream3fvATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream3fvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream3fvATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream3fvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream3fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream3fvATI(GLenum stream, GLfloat[] coords)
+
+        public static
+        void VertexStream3fvATI(GLenum stream, GLfloat[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream3fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream3dvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream3dvATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream3dvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream3dvATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream3dvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream3dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream3dvATI(GLenum stream, GLdouble[] coords)
+
+        public static
+        void VertexStream3dvATI(GLenum stream, GLdouble[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream3dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream4svATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream4svATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream4svATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream4svATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream4svATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream4svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream4svATI(GLenum stream, GLshort[] coords)
+
+        public static
+        void VertexStream4svATI(GLenum stream, GLshort[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream4svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream4ivATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream4ivATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream4ivATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream4ivATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream4ivATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream4ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream4ivATI(GLenum stream, GLint[] coords)
+
+        public static
+        void VertexStream4ivATI(GLenum stream, GLint[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream4ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream4fvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream4fvATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream4fvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream4fvATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream4fvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream4fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream4fvATI(GLenum stream, GLfloat[] coords)
+
+        public static
+        void VertexStream4fvATI(GLenum stream, GLfloat[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream4fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream4dvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void VertexStream4dvATI(GLenum stream, IntPtr coords)
+        {
+            VertexStream4dvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region VertexStream4dvATI(GLenum stream, object coords)
+
+        public static
+        void VertexStream4dvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream4dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexStream4dvATI(GLenum stream, GLdouble[] coords)
+
+        public static
+        void VertexStream4dvATI(GLenum stream, GLdouble[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                VertexStream4dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3bvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void NormalStream3bvATI(GLenum stream, IntPtr coords)
+        {
+            NormalStream3bvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region NormalStream3bvATI(GLenum stream, object coords)
+
+        public static
+        void NormalStream3bvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3bvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3bvATI(GLenum stream, GLbyte[] coords)
+
+        public static
+        void NormalStream3bvATI(GLenum stream, GLbyte[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3bvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3svATI(GLenum stream, IntPtr coords)
+
+        public static
+        void NormalStream3svATI(GLenum stream, IntPtr coords)
+        {
+            NormalStream3svATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region NormalStream3svATI(GLenum stream, object coords)
+
+        public static
+        void NormalStream3svATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3svATI(GLenum stream, GLshort[] coords)
+
+        public static
+        void NormalStream3svATI(GLenum stream, GLshort[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3svATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3ivATI(GLenum stream, IntPtr coords)
+
+        public static
+        void NormalStream3ivATI(GLenum stream, IntPtr coords)
+        {
+            NormalStream3ivATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region NormalStream3ivATI(GLenum stream, object coords)
+
+        public static
+        void NormalStream3ivATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3ivATI(GLenum stream, GLint[] coords)
+
+        public static
+        void NormalStream3ivATI(GLenum stream, GLint[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3ivATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3fvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void NormalStream3fvATI(GLenum stream, IntPtr coords)
+        {
+            NormalStream3fvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region NormalStream3fvATI(GLenum stream, object coords)
+
+        public static
+        void NormalStream3fvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3fvATI(GLenum stream, GLfloat[] coords)
+
+        public static
+        void NormalStream3fvATI(GLenum stream, GLfloat[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3fvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3dvATI(GLenum stream, IntPtr coords)
+
+        public static
+        void NormalStream3dvATI(GLenum stream, IntPtr coords)
+        {
+            NormalStream3dvATI_(stream, coords);
+        }
+
+        #endregion
+
+        #region NormalStream3dvATI(GLenum stream, object coords)
+
+        public static
+        void NormalStream3dvATI(GLenum stream, object coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region NormalStream3dvATI(GLenum stream, GLdouble[] coords)
+
+        public static
+        void NormalStream3dvATI(GLenum stream, GLdouble[] coords)
+        {
+            GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+            try
+            {
+                NormalStream3dvATI_(stream, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ElementPointerATI(GLenum type, IntPtr pointer)
+
+        public static
+        void ElementPointerATI(GLenum type, IntPtr pointer)
+        {
+            ElementPointerATI_(type, pointer);
+        }
+
+        #endregion
+
+        #region ElementPointerATI(GLenum type, object pointer)
+
+        public static
+        void ElementPointerATI(GLenum type, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ElementPointerATI_(type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenOcclusionQueriesNV(GLsizei n, IntPtr ids)
+
+        public static
+        void GenOcclusionQueriesNV(GLsizei n, IntPtr ids)
+        {
+            GenOcclusionQueriesNV_(n, ids);
+        }
+
+        #endregion
+
+        #region GenOcclusionQueriesNV(GLsizei n, object ids)
+
+        public static
+        void GenOcclusionQueriesNV(GLsizei n, object ids)
+        {
+            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+            try
+            {
+                GenOcclusionQueriesNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenOcclusionQueriesNV(GLsizei n, GLuint[] ids)
+
+        public static
+        void GenOcclusionQueriesNV(GLsizei n, GLuint[] ids)
+        {
+            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+            try
+            {
+                GenOcclusionQueriesNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteOcclusionQueriesNV(GLsizei n, IntPtr ids)
+
+        public static
+        void DeleteOcclusionQueriesNV(GLsizei n, IntPtr ids)
+        {
+            DeleteOcclusionQueriesNV_(n, ids);
+        }
+
+        #endregion
+
+        #region DeleteOcclusionQueriesNV(GLsizei n, object ids)
+
+        public static
+        void DeleteOcclusionQueriesNV(GLsizei n, object ids)
+        {
+            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+            try
+            {
+                DeleteOcclusionQueriesNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteOcclusionQueriesNV(GLsizei n, GLuint[] ids)
+
+        public static
+        void DeleteOcclusionQueriesNV(GLsizei n, GLuint[] ids)
+        {
+            GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+            try
+            {
+                DeleteOcclusionQueriesNV_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetOcclusionQueryivNV(GLuint id, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetOcclusionQueryivNV(GLuint id, GLenum pname, IntPtr parameters)
+        {
+            GetOcclusionQueryivNV_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetOcclusionQueryivNV(GLuint id, GLenum pname, object parameters)
+
+        public static
+        void GetOcclusionQueryivNV(GLuint id, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetOcclusionQueryivNV_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetOcclusionQueryivNV(GLuint id, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetOcclusionQueryivNV(GLuint id, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetOcclusionQueryivNV_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetOcclusionQueryuivNV(GLuint id, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetOcclusionQueryuivNV(GLuint id, GLenum pname, IntPtr parameters)
+        {
+            GetOcclusionQueryuivNV_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetOcclusionQueryuivNV(GLuint id, GLenum pname, object parameters)
+
+        public static
+        void GetOcclusionQueryuivNV(GLuint id, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetOcclusionQueryuivNV_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint[] parameters)
+
+        public static
+        void GetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetOcclusionQueryuivNV_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PointParameterivNV(GLenum pname, IntPtr parameters)
+
+        public static
+        void PointParameterivNV(GLenum pname, IntPtr parameters)
+        {
+            PointParameterivNV_(pname, parameters);
+        }
+
+        #endregion
+
+        #region PointParameterivNV(GLenum pname, object parameters)
+
+        public static
+        void PointParameterivNV(GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PointParameterivNV_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PointParameterivNV(GLenum pname, GLint[] parameters)
+
+        public static
+        void PointParameterivNV(GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                PointParameterivNV_(pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ElementPointerAPPLE(GLenum type, IntPtr pointer)
+
+        public static
+        void ElementPointerAPPLE(GLenum type, IntPtr pointer)
+        {
+            ElementPointerAPPLE_(type, pointer);
+        }
+
+        #endregion
+
+        #region ElementPointerAPPLE(GLenum type, object pointer)
+
+        public static
+        void ElementPointerAPPLE(GLenum type, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                ElementPointerAPPLE_(type, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, IntPtr count, GLsizei primcount)
+        {
+            MultiDrawElementArrayAPPLE_(mode, first, count, primcount);
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementArrayAPPLE_(mode, first, h0.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, IntPtr first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementArrayAPPLE_(mode, first, h0.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, IntPtr count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), count, primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, object first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, IntPtr count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), count, primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawElementArrayAPPLE_(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, IntPtr count, GLsizei primcount)
+        {
+            MultiDrawRangeElementArrayAPPLE_(mode, start, end, first, count, primcount);
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawRangeElementArrayAPPLE_(mode, start, end, first, h0.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, IntPtr first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawRangeElementArrayAPPLE_(mode, start, end, first, h0.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, IntPtr count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), count, primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, object first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, IntPtr count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, IntPtr count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), count, primcount);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, object count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, object count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei[] count, GLsizei primcount)
+
+        public static
+        void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei[] count, GLsizei primcount)
+        {
+            GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+            try
+            {
+                MultiDrawRangeElementArrayAPPLE_(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenFencesAPPLE(GLsizei n, IntPtr fences)
+
+        public static
+        void GenFencesAPPLE(GLsizei n, IntPtr fences)
+        {
+            GenFencesAPPLE_(n, fences);
+        }
+
+        #endregion
+
+        #region GenFencesAPPLE(GLsizei n, object fences)
+
+        public static
+        void GenFencesAPPLE(GLsizei n, object fences)
+        {
+            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+            try
+            {
+                GenFencesAPPLE_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenFencesAPPLE(GLsizei n, GLuint[] fences)
+
+        public static
+        void GenFencesAPPLE(GLsizei n, GLuint[] fences)
+        {
+            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+            try
+            {
+                GenFencesAPPLE_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteFencesAPPLE(GLsizei n, IntPtr fences)
+
+        public static
+        void DeleteFencesAPPLE(GLsizei n, IntPtr fences)
+        {
+            DeleteFencesAPPLE_(n, fences);
+        }
+
+        #endregion
+
+        #region DeleteFencesAPPLE(GLsizei n, object fences)
+
+        public static
+        void DeleteFencesAPPLE(GLsizei n, object fences)
+        {
+            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+            try
+            {
+                DeleteFencesAPPLE_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteFencesAPPLE(GLsizei n, GLuint[] fences)
+
+        public static
+        void DeleteFencesAPPLE(GLsizei n, GLuint[] fences)
+        {
+            GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+            try
+            {
+                DeleteFencesAPPLE_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteVertexArraysAPPLE(GLsizei n, IntPtr arrays)
+
+        public static
+        void DeleteVertexArraysAPPLE(GLsizei n, IntPtr arrays)
+        {
+            DeleteVertexArraysAPPLE_(n, arrays);
+        }
+
+        #endregion
+
+        #region DeleteVertexArraysAPPLE(GLsizei n, object arrays)
+
+        public static
+        void DeleteVertexArraysAPPLE(GLsizei n, object arrays)
+        {
+            GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
+            try
+            {
+                DeleteVertexArraysAPPLE_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
+
+        public static
+        void DeleteVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
+        {
+            GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
+            try
+            {
+                DeleteVertexArraysAPPLE_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenVertexArraysAPPLE(GLsizei n, IntPtr arrays)
+
+        public static
+        void GenVertexArraysAPPLE(GLsizei n, IntPtr arrays)
+        {
+            GenVertexArraysAPPLE_(n, arrays);
+        }
+
+        #endregion
+
+        #region GenVertexArraysAPPLE(GLsizei n, object arrays)
+
+        public static
+        void GenVertexArraysAPPLE(GLsizei n, object arrays)
+        {
+            GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
+            try
+            {
+                GenVertexArraysAPPLE_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
+
+        public static
+        void GenVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
+        {
+            GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
+            try
+            {
+                GenVertexArraysAPPLE_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexArrayRangeAPPLE(GLsizei length, IntPtr pointer)
+
+        public static
+        void VertexArrayRangeAPPLE(GLsizei length, IntPtr pointer)
+        {
+            VertexArrayRangeAPPLE_(length, pointer);
+        }
+
+        #endregion
+
+        #region VertexArrayRangeAPPLE(GLsizei length, object pointer)
+
+        public static
+        void VertexArrayRangeAPPLE(GLsizei length, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                VertexArrayRangeAPPLE_(length, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FlushVertexArrayRangeAPPLE(GLsizei length, IntPtr pointer)
+
+        public static
+        void FlushVertexArrayRangeAPPLE(GLsizei length, IntPtr pointer)
+        {
+            FlushVertexArrayRangeAPPLE_(length, pointer);
+        }
+
+        #endregion
+
+        #region FlushVertexArrayRangeAPPLE(GLsizei length, object pointer)
+
+        public static
+        void FlushVertexArrayRangeAPPLE(GLsizei length, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                FlushVertexArrayRangeAPPLE_(length, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DrawBuffersATI(GLsizei n, IntPtr bufs)
+
+        public static
+        void DrawBuffersATI(GLsizei n, IntPtr bufs)
+        {
+            DrawBuffersATI_(n, bufs);
+        }
+
+        #endregion
+
+        #region DrawBuffersATI(GLsizei n, object bufs)
+
+        public static
+        void DrawBuffersATI(GLsizei n, object bufs)
+        {
+            GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+            try
+            {
+                DrawBuffersATI_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DrawBuffersATI(GLsizei n, GLenum[] bufs)
+
+        public static
+        void DrawBuffersATI(GLsizei n, GLenum[] bufs)
+        {
+            GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+            try
+            {
+                DrawBuffersATI_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fNV(GLuint id, GLsizei len, IntPtr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+
+        public static
+        void ProgramNamedParameter4fNV(GLuint id, GLsizei len, IntPtr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+        {
+            ProgramNamedParameter4fNV_(id, len, name, x, y, z, w);
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fNV(GLuint id, GLsizei len, object name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+
+        public static
+        void ProgramNamedParameter4fNV(GLuint id, GLsizei len, object name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fNV_(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+
+        public static
+        void ProgramNamedParameter4fNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fNV_(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dNV(GLuint id, GLsizei len, IntPtr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+
+        public static
+        void ProgramNamedParameter4dNV(GLuint id, GLsizei len, IntPtr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+        {
+            ProgramNamedParameter4dNV_(id, len, name, x, y, z, w);
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dNV(GLuint id, GLsizei len, object name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+
+        public static
+        void ProgramNamedParameter4dNV(GLuint id, GLsizei len, object name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dNV_(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+
+        public static
+        void ProgramNamedParameter4dNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dNV_(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, IntPtr v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, IntPtr v)
+        {
+            ProgramNamedParameter4fvNV_(id, len, name, v);
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, object v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fvNV_(id, len, name, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, GLfloat[] v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, IntPtr name, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fvNV_(id, len, name, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, IntPtr v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, object v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, GLfloat[] v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, object name, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, object v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] v)
+
+        public static
+        void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4fvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, IntPtr v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, IntPtr v)
+        {
+            ProgramNamedParameter4dvNV_(id, len, name, v);
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, object v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dvNV_(id, len, name, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, GLdouble[] v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, IntPtr name, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dvNV_(id, len, name, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, IntPtr v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, object v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, GLdouble[] v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, object name, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), v);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, object v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] v)
+
+        public static
+        void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                ProgramNamedParameter4dvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, IntPtr parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, IntPtr parameters)
+        {
+            GetProgramNamedParameterfvNV_(id, len, name, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, object parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterfvNV_(id, len, name, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, GLfloat[] parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, IntPtr name, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterfvNV_(id, len, name, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, IntPtr parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, IntPtr parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), parameters);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, object parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, GLfloat[] parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, object name, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), parameters);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, object parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] parameters)
+
+        public static
+        void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterfvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, IntPtr parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, IntPtr parameters)
+        {
+            GetProgramNamedParameterdvNV_(id, len, name, parameters);
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, object parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterdvNV_(id, len, name, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, GLdouble[] parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, IntPtr name, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterdvNV_(id, len, name, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, IntPtr parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, IntPtr parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), parameters);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, object parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, GLdouble[] parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, object name, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, IntPtr parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), parameters);
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, object parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] parameters)
+
+        public static
+        void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+            GCHandle h1 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetProgramNamedParameterdvNV_(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h1.Free();
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Vertex2hvNV(IntPtr v)
+
+        public static
+        void Vertex2hvNV(IntPtr v)
+        {
+            Vertex2hvNV_(v);
+        }
+
+        #endregion
+
+        #region Vertex2hvNV(object v)
+
+        public static
+        void Vertex2hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Vertex2hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Vertex2hvNV(GLhalfNV[] v)
+
+        public static
+        void Vertex2hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Vertex2hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Vertex3hvNV(IntPtr v)
+
+        public static
+        void Vertex3hvNV(IntPtr v)
+        {
+            Vertex3hvNV_(v);
+        }
+
+        #endregion
+
+        #region Vertex3hvNV(object v)
+
+        public static
+        void Vertex3hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Vertex3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Vertex3hvNV(GLhalfNV[] v)
+
+        public static
+        void Vertex3hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Vertex3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Vertex4hvNV(IntPtr v)
+
+        public static
+        void Vertex4hvNV(IntPtr v)
+        {
+            Vertex4hvNV_(v);
+        }
+
+        #endregion
+
+        #region Vertex4hvNV(object v)
+
+        public static
+        void Vertex4hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Vertex4hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Vertex4hvNV(GLhalfNV[] v)
+
+        public static
+        void Vertex4hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Vertex4hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3hvNV(IntPtr v)
+
+        public static
+        void Normal3hvNV(IntPtr v)
+        {
+            Normal3hvNV_(v);
+        }
+
+        #endregion
+
+        #region Normal3hvNV(object v)
+
+        public static
+        void Normal3hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Normal3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Normal3hvNV(GLhalfNV[] v)
+
+        public static
+        void Normal3hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Normal3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3hvNV(IntPtr v)
+
+        public static
+        void Color3hvNV(IntPtr v)
+        {
+            Color3hvNV_(v);
+        }
+
+        #endregion
+
+        #region Color3hvNV(object v)
+
+        public static
+        void Color3hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color3hvNV(GLhalfNV[] v)
+
+        public static
+        void Color3hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4hvNV(IntPtr v)
+
+        public static
+        void Color4hvNV(IntPtr v)
+        {
+            Color4hvNV_(v);
+        }
+
+        #endregion
+
+        #region Color4hvNV(object v)
+
+        public static
+        void Color4hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region Color4hvNV(GLhalfNV[] v)
+
+        public static
+        void Color4hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                Color4hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord1hvNV(IntPtr v)
+
+        public static
+        void TexCoord1hvNV(IntPtr v)
+        {
+            TexCoord1hvNV_(v);
+        }
+
+        #endregion
+
+        #region TexCoord1hvNV(object v)
+
+        public static
+        void TexCoord1hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord1hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord1hvNV(GLhalfNV[] v)
+
+        public static
+        void TexCoord1hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord1hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2hvNV(IntPtr v)
+
+        public static
+        void TexCoord2hvNV(IntPtr v)
+        {
+            TexCoord2hvNV_(v);
+        }
+
+        #endregion
+
+        #region TexCoord2hvNV(object v)
+
+        public static
+        void TexCoord2hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord2hvNV(GLhalfNV[] v)
+
+        public static
+        void TexCoord2hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord2hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord3hvNV(IntPtr v)
+
+        public static
+        void TexCoord3hvNV(IntPtr v)
+        {
+            TexCoord3hvNV_(v);
+        }
+
+        #endregion
+
+        #region TexCoord3hvNV(object v)
+
+        public static
+        void TexCoord3hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord3hvNV(GLhalfNV[] v)
+
+        public static
+        void TexCoord3hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4hvNV(IntPtr v)
+
+        public static
+        void TexCoord4hvNV(IntPtr v)
+        {
+            TexCoord4hvNV_(v);
+        }
+
+        #endregion
+
+        #region TexCoord4hvNV(object v)
+
+        public static
+        void TexCoord4hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region TexCoord4hvNV(GLhalfNV[] v)
+
+        public static
+        void TexCoord4hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                TexCoord4hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1hvNV(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord1hvNV(GLenum target, IntPtr v)
+        {
+            MultiTexCoord1hvNV_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord1hvNV(GLenum target, object v)
+
+        public static
+        void MultiTexCoord1hvNV(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1hvNV_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord1hvNV(GLenum target, GLhalfNV[] v)
+
+        public static
+        void MultiTexCoord1hvNV(GLenum target, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord1hvNV_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2hvNV(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord2hvNV(GLenum target, IntPtr v)
+        {
+            MultiTexCoord2hvNV_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord2hvNV(GLenum target, object v)
+
+        public static
+        void MultiTexCoord2hvNV(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2hvNV_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord2hvNV(GLenum target, GLhalfNV[] v)
+
+        public static
+        void MultiTexCoord2hvNV(GLenum target, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord2hvNV_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3hvNV(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord3hvNV(GLenum target, IntPtr v)
+        {
+            MultiTexCoord3hvNV_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord3hvNV(GLenum target, object v)
+
+        public static
+        void MultiTexCoord3hvNV(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3hvNV_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord3hvNV(GLenum target, GLhalfNV[] v)
+
+        public static
+        void MultiTexCoord3hvNV(GLenum target, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord3hvNV_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4hvNV(GLenum target, IntPtr v)
+
+        public static
+        void MultiTexCoord4hvNV(GLenum target, IntPtr v)
+        {
+            MultiTexCoord4hvNV_(target, v);
+        }
+
+        #endregion
+
+        #region MultiTexCoord4hvNV(GLenum target, object v)
+
+        public static
+        void MultiTexCoord4hvNV(GLenum target, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4hvNV_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region MultiTexCoord4hvNV(GLenum target, GLhalfNV[] v)
+
+        public static
+        void MultiTexCoord4hvNV(GLenum target, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                MultiTexCoord4hvNV_(target, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoordhvNV(IntPtr fog)
+
+        public static
+        void FogCoordhvNV(IntPtr fog)
+        {
+            FogCoordhvNV_(fog);
+        }
+
+        #endregion
+
+        #region FogCoordhvNV(object fog)
+
+        public static
+        void FogCoordhvNV(object fog)
+        {
+            GCHandle h0 = GCHandle.Alloc(fog, GCHandleType.Pinned);
+            try
+            {
+                FogCoordhvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region FogCoordhvNV(GLhalfNV[] fog)
+
+        public static
+        void FogCoordhvNV(GLhalfNV[] fog)
+        {
+            GCHandle h0 = GCHandle.Alloc(fog, GCHandleType.Pinned);
+            try
+            {
+                FogCoordhvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3hvNV(IntPtr v)
+
+        public static
+        void SecondaryColor3hvNV(IntPtr v)
+        {
+            SecondaryColor3hvNV_(v);
+        }
+
+        #endregion
+
+        #region SecondaryColor3hvNV(object v)
+
+        public static
+        void SecondaryColor3hvNV(object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region SecondaryColor3hvNV(GLhalfNV[] v)
+
+        public static
+        void SecondaryColor3hvNV(GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                SecondaryColor3hvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexWeighthvNV(IntPtr weight)
+
+        public static
+        void VertexWeighthvNV(IntPtr weight)
+        {
+            VertexWeighthvNV_(weight);
+        }
+
+        #endregion
+
+        #region VertexWeighthvNV(object weight)
+
+        public static
+        void VertexWeighthvNV(object weight)
+        {
+            GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
+            try
+            {
+                VertexWeighthvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexWeighthvNV(GLhalfNV[] weight)
+
+        public static
+        void VertexWeighthvNV(GLhalfNV[] weight)
+        {
+            GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
+            try
+            {
+                VertexWeighthvNV_(h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1hvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib1hvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib1hvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib1hvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib1hvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1hvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib1hvNV(GLuint index, GLhalfNV[] v)
+
+        public static
+        void VertexAttrib1hvNV(GLuint index, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib1hvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2hvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib2hvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib2hvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib2hvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib2hvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2hvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib2hvNV(GLuint index, GLhalfNV[] v)
+
+        public static
+        void VertexAttrib2hvNV(GLuint index, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib2hvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3hvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib3hvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib3hvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib3hvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib3hvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3hvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib3hvNV(GLuint index, GLhalfNV[] v)
+
+        public static
+        void VertexAttrib3hvNV(GLuint index, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib3hvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4hvNV(GLuint index, IntPtr v)
+
+        public static
+        void VertexAttrib4hvNV(GLuint index, IntPtr v)
+        {
+            VertexAttrib4hvNV_(index, v);
+        }
+
+        #endregion
+
+        #region VertexAttrib4hvNV(GLuint index, object v)
+
+        public static
+        void VertexAttrib4hvNV(GLuint index, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4hvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttrib4hvNV(GLuint index, GLhalfNV[] v)
+
+        public static
+        void VertexAttrib4hvNV(GLuint index, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttrib4hvNV_(index, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs1hvNV(GLuint index, GLsizei n, IntPtr v)
+
+        public static
+        void VertexAttribs1hvNV(GLuint index, GLsizei n, IntPtr v)
+        {
+            VertexAttribs1hvNV_(index, n, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs1hvNV(GLuint index, GLsizei n, object v)
+
+        public static
+        void VertexAttribs1hvNV(GLuint index, GLsizei n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs1hvNV_(index, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs1hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+
+        public static
+        void VertexAttribs1hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs1hvNV_(index, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs2hvNV(GLuint index, GLsizei n, IntPtr v)
+
+        public static
+        void VertexAttribs2hvNV(GLuint index, GLsizei n, IntPtr v)
+        {
+            VertexAttribs2hvNV_(index, n, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs2hvNV(GLuint index, GLsizei n, object v)
+
+        public static
+        void VertexAttribs2hvNV(GLuint index, GLsizei n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs2hvNV_(index, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs2hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+
+        public static
+        void VertexAttribs2hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs2hvNV_(index, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs3hvNV(GLuint index, GLsizei n, IntPtr v)
+
+        public static
+        void VertexAttribs3hvNV(GLuint index, GLsizei n, IntPtr v)
+        {
+            VertexAttribs3hvNV_(index, n, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs3hvNV(GLuint index, GLsizei n, object v)
+
+        public static
+        void VertexAttribs3hvNV(GLuint index, GLsizei n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs3hvNV_(index, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs3hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+
+        public static
+        void VertexAttribs3hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs3hvNV_(index, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4hvNV(GLuint index, GLsizei n, IntPtr v)
+
+        public static
+        void VertexAttribs4hvNV(GLuint index, GLsizei n, IntPtr v)
+        {
+            VertexAttribs4hvNV_(index, n, v);
+        }
+
+        #endregion
+
+        #region VertexAttribs4hvNV(GLuint index, GLsizei n, object v)
+
+        public static
+        void VertexAttribs4hvNV(GLuint index, GLsizei n, object v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4hvNV_(index, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region VertexAttribs4hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+
+        public static
+        void VertexAttribs4hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+        {
+            GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+            try
+            {
+                VertexAttribs4hvNV_(index, n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region PixelDataRangeNV(GLenum target, GLsizei length, IntPtr pointer)
+
+        public static
+        void PixelDataRangeNV(GLenum target, GLsizei length, IntPtr pointer)
+        {
+            PixelDataRangeNV_(target, length, pointer);
+        }
+
+        #endregion
+
+        #region PixelDataRangeNV(GLenum target, GLsizei length, object pointer)
+
+        public static
+        void PixelDataRangeNV(GLenum target, GLsizei length, object pointer)
+        {
+            GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+            try
+            {
+                PixelDataRangeNV_(target, length, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetVertexAttribArrayObjectfvATI_(index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribArrayObjectfvATI_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat[] parameters)
+
+        public static
+        void GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribArrayObjectfvATI_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, IntPtr parameters)
+
+        public static
+        void GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, IntPtr parameters)
+        {
+            GetVertexAttribArrayObjectivATI_(index, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, object parameters)
+
+        public static
+        void GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribArrayObjectivATI_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint[] parameters)
+
+        public static
+        void GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetVertexAttribArrayObjectivATI_(index, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteRenderbuffersEXT(GLsizei n, IntPtr renderbuffers)
+
+        public static
+        void DeleteRenderbuffersEXT(GLsizei n, IntPtr renderbuffers)
+        {
+            DeleteRenderbuffersEXT_(n, renderbuffers);
+        }
+
+        #endregion
+
+        #region DeleteRenderbuffersEXT(GLsizei n, object renderbuffers)
+
+        public static
+        void DeleteRenderbuffersEXT(GLsizei n, object renderbuffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
+            try
+            {
+                DeleteRenderbuffersEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
+
+        public static
+        void DeleteRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
+            try
+            {
+                DeleteRenderbuffersEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenRenderbuffersEXT(GLsizei n, IntPtr renderbuffers)
+
+        public static
+        void GenRenderbuffersEXT(GLsizei n, IntPtr renderbuffers)
+        {
+            GenRenderbuffersEXT_(n, renderbuffers);
+        }
+
+        #endregion
+
+        #region GenRenderbuffersEXT(GLsizei n, object renderbuffers)
+
+        public static
+        void GenRenderbuffersEXT(GLsizei n, object renderbuffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
+            try
+            {
+                GenRenderbuffersEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
+
+        public static
+        void GenRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
+            try
+            {
+                GenRenderbuffersEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, IntPtr parameters)
+
+        public static
+        void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, IntPtr parameters)
+        {
+            GetRenderbufferParameterivEXT_(target, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, object parameters)
+
+        public static
+        void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetRenderbufferParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, GLint[] parameters)
+
+        public static
+        void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetRenderbufferParameterivEXT_(target, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteFramebuffersEXT(GLsizei n, IntPtr framebuffers)
+
+        public static
+        void DeleteFramebuffersEXT(GLsizei n, IntPtr framebuffers)
+        {
+            DeleteFramebuffersEXT_(n, framebuffers);
+        }
+
+        #endregion
+
+        #region DeleteFramebuffersEXT(GLsizei n, object framebuffers)
+
+        public static
+        void DeleteFramebuffersEXT(GLsizei n, object framebuffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
+            try
+            {
+                DeleteFramebuffersEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region DeleteFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
+
+        public static
+        void DeleteFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
+            try
+            {
+                DeleteFramebuffersEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenFramebuffersEXT(GLsizei n, IntPtr framebuffers)
+
+        public static
+        void GenFramebuffersEXT(GLsizei n, IntPtr framebuffers)
+        {
+            GenFramebuffersEXT_(n, framebuffers);
+        }
+
+        #endregion
+
+        #region GenFramebuffersEXT(GLsizei n, object framebuffers)
+
+        public static
+        void GenFramebuffersEXT(GLsizei n, object framebuffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
+            try
+            {
+                GenFramebuffersEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GenFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
+
+        public static
+        void GenFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
+        {
+            GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
+            try
+            {
+                GenFramebuffersEXT_(n, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, IntPtr parameters)
+
+        public static
+        void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, IntPtr parameters)
+        {
+            GetFramebufferAttachmentParameterivEXT_(target, attachment, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, object parameters)
+
+        public static
+        void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFramebufferAttachmentParameterivEXT_(target, attachment, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, GLint[] parameters)
+
+        public static
+        void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object pname, GLint[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetFramebufferAttachmentParameterivEXT_(target, attachment, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region StringMarkerGREMEDY(GLsizei len, IntPtr @string)
+
+        public static
+        void StringMarkerGREMEDY(GLsizei len, IntPtr @string)
+        {
+            StringMarkerGREMEDY_(len, @string);
+        }
+
+        #endregion
+
+        #region StringMarkerGREMEDY(GLsizei len, object @string)
+
+        public static
+        void StringMarkerGREMEDY(GLsizei len, object @string)
+        {
+            GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
+            try
+            {
+                StringMarkerGREMEDY_(len, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters)
+
+        public static
+        void GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters)
+        {
+            GetQueryObjecti64vEXT_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, object parameters)
+
+        public static
+        void GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryObjecti64vEXT_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, GLint64[] parameters)
+
+        public static
+        void GetQueryObjecti64vEXT(GLuint id, Enums.EXT_timer_query pname, GLint64[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryObjecti64vEXT_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters)
+
+        public static
+        void GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, IntPtr parameters)
+        {
+            GetQueryObjectui64vEXT_(id, pname, parameters);
+        }
+
+        #endregion
+
+        #region GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, object parameters)
+
+        public static
+        void GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryObjectui64vEXT_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, GLuint64[] parameters)
+
+        public static
+        void GetQueryObjectui64vEXT(GLuint id, Enums.EXT_timer_query pname, GLuint64[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                GetQueryObjectui64vEXT_(id, pname, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, IntPtr parameters)
+
+        public static
+        void ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, IntPtr parameters)
+        {
+            ProgramEnvParameters4fvEXT_(target, index, count, parameters);
+        }
+
+        #endregion
+
+        #region ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, object parameters)
+
+        public static
+        void ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramEnvParameters4fvEXT_(target, index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat[] parameters)
+
+        public static
+        void ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramEnvParameters4fvEXT_(target, index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, IntPtr parameters)
+
+        public static
+        void ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, IntPtr parameters)
+        {
+            ProgramLocalParameters4fvEXT_(target, index, count, parameters);
+        }
+
+        #endregion
+
+        #region ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, object parameters)
+
+        public static
+        void ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, object parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramLocalParameters4fvEXT_(target, index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #region ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat[] parameters)
+
+        public static
+        void ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, GLfloat[] parameters)
+        {
+            GCHandle h0 = GCHandle.Alloc(parameters, GCHandleType.Pinned);
+            try
+            {
+                ProgramLocalParameters4fvEXT_(target, index, count, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
+
+        #endregion
+
+        #endregion
+        }
+    }
+}
+
diff --git a/Source/OpenGL/OpenGL/Contexts/GLContext.cs b/Source/OpenGL/OpenGL/Contexts/GLContext.cs
index 2da6bcb1..d8531393 100644
--- a/Source/OpenGL/OpenGL/Contexts/GLContext.cs
+++ b/Source/OpenGL/OpenGL/Contexts/GLContext.cs
@@ -38,10 +38,10 @@ namespace OpenTK.OpenGL
                 {
                     return new WindowsContext(c, red, green, blue, alpha, depth, stencil);
                 }
-                else if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major >= 6)
-                {
-                    return new WindowsVistaContext(c, red, green, blue, alpha, depth, stencil);
-                }
+                //else if (Environment.OSVersion.Platform == PlatformID.Win32NT && Environment.OSVersion.Version.Major >= 6)
+                //{
+                //    return new WindowsVistaContext(c, red, green, blue, alpha, depth, stencil);
+                //}
                 else if (Environment.OSVersion.Platform == PlatformID.Unix)
                 {
                     return new X11Context(c, red, green, blue, alpha, depth, stencil);
diff --git a/Source/OpenGL/OpenGL/Contexts/WindowsContext.cs b/Source/OpenGL/OpenGL/Contexts/WindowsContext.cs
index 1abeebdf..37d54827 100644
--- a/Source/OpenGL/OpenGL/Contexts/WindowsContext.cs
+++ b/Source/OpenGL/OpenGL/Contexts/WindowsContext.cs
@@ -89,7 +89,8 @@ namespace OpenTK.OpenGL.Platform
 
             MakeCurrent();
 
-            Load();
+            //GL.Init();
+            //new GL();
 
             //if (load_extensions)
             //    LoadExtensions();
diff --git a/Source/OpenGL/OpenGL/Contexts/WindowsVistaContext.cs b/Source/OpenGL/OpenGL/Contexts/WindowsVistaContext.cs
index ea0397eb..ebca61cf 100644
--- a/Source/OpenGL/OpenGL/Contexts/WindowsVistaContext.cs
+++ b/Source/OpenGL/OpenGL/Contexts/WindowsVistaContext.cs
@@ -87,7 +87,8 @@ namespace OpenTK.OpenGL.Platform
 
             MakeCurrent();
 
-            Load();
+            //GL.Init();
+            //new GL();
 
             //if (load_extensions)
             //    LoadExtensions();
diff --git a/Source/OpenGL/OpenGL/Contexts/X11Context.cs b/Source/OpenGL/OpenGL/Contexts/X11Context.cs
index f769f284..0937774b 100644
--- a/Source/OpenGL/OpenGL/Contexts/X11Context.cs
+++ b/Source/OpenGL/OpenGL/Contexts/X11Context.cs
@@ -15,30 +15,55 @@ namespace OpenTK.OpenGL.Platform
 {
     public partial class X11Context : OpenTK.OpenGL.GLContext
     {
-        int drawable;
-        IntPtr context;
-        IntPtr display;
-        const string _dll_name = "opengl.so";
+        //private IntPtr drawable;
+        private IntPtr Handle;
+        private IntPtr GLXVisualInfo;
+        private IntPtr context;
+        private IntPtr display;
+        const string _dll_name = "libGL.so.1";
 
         public X11Context(Control c, int red, int green, int blue, int alpha, int depth, int stencil)
         {
-            //drawable = c.Handle.ToInt32();
-            display = Api.OpenDisplay("OpenTK X11 trial");
-            Api.VisualInfo visual = Glx.ChooseVisual(display, 0, new int[] { });
-            context = Glx.CreateContext(display, visual, IntPtr.Zero, true);
-            //Api.Free(new IntPtr(visual));
-            drawable = c.Handle.ToInt32();
-            Glx.MakeCurrent(drawable, context);
-            
-            //context = Glx.CreateContext(
-                //X11Context
+            Type xplatui = Type.GetType("System.Windows.Forms.XplatUIX11, System.Windows.Forms");
+            if (xplatui != null)
+            {
+                IntPtr display = (IntPtr)xplatui.GetField("DisplayHandle", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic).GetValue(null);
+                IntPtr RootWindow = (IntPtr)xplatui.GetField("RootWindow", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic).GetValue(null);
+                int ScreenNo = (int)xplatui.GetField("ScreenNo", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic).GetValue(null);
+                
+                Handle = c.Handle;
+                
+                int[] dblBuf = new int[]
+                { 
+                    5, 
+                    (int)Glx.Enums.GLXAttribute.RGBA,
+                    (int)Glx.Enums.GLXAttribute.RED_SIZE, 1,
+                    (int)Glx.Enums.GLXAttribute.GREEN_SIZE, 1,
+                    (int)Glx.Enums.GLXAttribute.BLUE_SIZE, 1,
+                    (int)Glx.Enums.GLXAttribute.DEPTH_SIZE, 1,
+                    0
+                };
+                GLXVisualInfo = Glx.ChooseVisual(display, ScreenNo, dblBuf);
 
-            //throw new Exception("The method or operation is not implemented.");
+                Api.VisualInfo xVisualInfo = (Api.VisualInfo)Marshal.PtrToStructure(GLXVisualInfo, typeof(Api.VisualInfo));
+                IntPtr visual = xVisualInfo.visual;
+                IntPtr colormap = Api.CreateColormap(display, RootWindow, visual, 0/*AllocNone*/);
+
+                xplatui.GetField("CustomVisual", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic).SetValue(null, visual);
+                xplatui.GetField("CustomColormap", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic).SetValue(null, colormap);
+                
+                context = Glx.CreateContext(display, GLXVisualInfo, IntPtr.Zero, true);
+                
+                MakeCurrent();
+
+                //GL.Init();
+                //new GL();
+            }
         }
 
         public override void SwapBuffers()
         {
-            Glx.SwapBuffers(drawable);
+            Glx.SwapBuffers(display, Handle);
         }
 
         public override Delegate GetAddress(string function_string, Type function_type)
@@ -52,7 +77,7 @@ namespace OpenTK.OpenGL.Platform
 
         public override void MakeCurrent()
         {
-            Glx.MakeCurrent(drawable, context);
+            Glx.MakeCurrent(display, Handle, context);
         }
 
         public override void Dispose()
diff --git a/Source/OpenGL/OpenGL/GL.cs b/Source/OpenGL/OpenGL/GL.cs
new file mode 100644
index 00000000..c42fc627
--- /dev/null
+++ b/Source/OpenGL/OpenGL/GL.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace OpenTK.OpenGL
+{
+    public static partial class GL
+    {
+        private static Delegate WindowsGetAddress(string function_string, Type function_type)
+        {
+            IntPtr address = Wgl.GetProcAddress(function_string);
+            if (address == IntPtr.Zero)
+                return null;
+            else
+                return Marshal.GetDelegateForFunctionPointer(address, function_type);
+        }
+
+        private static Delegate X11GetAddress(string function_string, Type function_type)
+        {
+            IntPtr address = Glx.GetProcAddress(function_string);
+            if (address == IntPtr.Zero)
+                return null;
+            else
+                return Marshal.GetDelegateForFunctionPointer(address, function_type);
+        }
+
+        private static Delegate MacOSGetAddress(string function_string, Type function_type)
+        {
+            throw new NotImplementedException("THis platform is not supported yet. Sorry for the inconvenience.");
+        }
+    }
+}
diff --git a/Source/OpenGL/OpenGL/Glu.cs b/Source/OpenGL/OpenGL/Glu.cs
index e8706164..c8b48015 100644
--- a/Source/OpenGL/OpenGL/Glu.cs
+++ b/Source/OpenGL/OpenGL/Glu.cs
@@ -16,7 +16,7 @@ namespace OpenTK.OpenGL
     {
         #region GLU functions
 
-        private const string GLUDLLName = "GLU32.DLL";
+        private const string GLUDLLName = "glu32.dll";
 
         [DllImport(GLUDLLName, EntryPoint = "gluOrtho2D")]
         private static extern IntPtr ErrorString_(int errCode);
diff --git a/Source/OpenGL/OpenGL/Glx.cs b/Source/OpenGL/OpenGL/Glx.cs
index 1c097046..628ced71 100644
--- a/Source/OpenGL/OpenGL/Glx.cs
+++ b/Source/OpenGL/OpenGL/Glx.cs
@@ -44,7 +44,7 @@ namespace OpenTK.OpenGL
     /// </summary>
     public class Glx
     {
-        const string _dll_name = "libgl";
+        const string _dll_name = "libGL.so.1";
 
         #region Enums
 
@@ -267,45 +267,42 @@ namespace OpenTK.OpenGL
         #region GLX functions
 
         [DllImport(_dll_name, EntryPoint = "glXCreateContext")]
-        public static extern IntPtr CreateContext(IntPtr dpy, Api.VisualInfo vis, IntPtr shareList, bool direct);
+        public static extern IntPtr CreateContext(IntPtr dpy, IntPtr vis, IntPtr shareList, bool direct);
+        //public static extern IntPtr CreateContext(IntPtr dpy, Api.VisualInfo vis, IntPtr shareList, bool direct);
         //public static extern IntPtr CreateContext(IntPtr gc_id, Int32 screen, Int32 visual, IntPtr share_list);
         
         [DllImport(_dll_name, EntryPoint = "glXDestroyContext")]
         public static extern void DestroyContext(IntPtr context);
 
         [DllImport(_dll_name, EntryPoint = "glXMakeCurrent")]
-        public static extern void MakeCurrent(Int32 drawable, IntPtr context);
+        public static extern void MakeCurrent(IntPtr display, IntPtr drawable, IntPtr context);
         
         [DllImport(_dll_name, EntryPoint = "glXSwapBuffers")]
-        public static extern void SwapBuffers(Int32 drawable);
+        public static extern void SwapBuffers(IntPtr display, IntPtr drawable);
 
         [DllImport(_dll_name, EntryPoint = "glXGetProcAddress")]
         public static extern IntPtr GetProcAddress([MarshalAs(UnmanagedType.LPTStr)] string procName);
 
         [DllImport(_dll_name, EntryPoint = "glXChooseVisual")]
-        public static extern OpenTK.Platform.X.Api.VisualInfo ChooseVisual(IntPtr dpy, int screen, [MarshalAs(UnmanagedType.LPArray)]int[] attriblist);
+        extern public static IntPtr ChooseVisual_(IntPtr dpy, int screen, IntPtr attriblist);
 
-        //public static ChooseVisual()
+        #endregion
 
+        #region Wrappers
 
-        //[DllImport("opengl32.dll", EntryPoint = "glCreateWindow")]
-        //public static extern void CreateWindow(Int32 config, Int32 window, Int32 glxwindow);
-        //[DllImport("opengl32.dll", EntryPoint = "glDestroyWindow")]
-        //public static extern void DestroyWindow(Int32 glxwindow);
-        //[DllImport("opengl32.dll", EntryPoint = "glCreatePixmap")]
-        //public static extern void CreatePixmap(Int32 config, Int32 pixmap, Int32 glxpixmap);
-        //[DllImport("opengl32.dll", EntryPoint = "glDestroyPixmap")]
-        //public static extern void DestroyPixmap(Int32 glxpixmap);
-        //[DllImport("opengl32.dll", EntryPoint = "glCreateNewContext")]
-        //public static extern void CreateNewContext(Int32 config, Int32 render_type, Int32 share_list, Int32 direct);
-        //[DllImport("opengl32.dll", EntryPoint = "glQueryContext")]
-        //public static extern void QueryContext();
-        //[DllImport("opengl32.dll", EntryPoint = "glMakeContextCurrent")]
-        //public static extern void MakeContextCurrent(Int32 drawable, Int32 readdrawable, Int32 context);
-        //[DllImport("opengl32.dll", EntryPoint = "glCreatePbuffer")]
-        //public static extern void CreatePbuffer(Int32 config, Int32 pbuffer);
-        //[DllImport("opengl32.dll", EntryPoint = "glDestroyPbuffer")]
-        //public static extern void DestroyPbuffer(Int32 pbuffer);
+        public static IntPtr ChooseVisual(IntPtr dpy, int screen, int[] attriblist)
+        {
+            GCHandle h0 = GCHandle.Alloc(attriblist, GCHandleType.Pinned);
+
+            try
+            {
+                return ChooseVisual_(dpy, screen, h0.AddrOfPinnedObject());
+            }
+            finally
+            {
+                h0.Free();
+            }
+        }
 
         #endregion
     }
diff --git a/Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj b/Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj
index 7eeb8d38..0bd517dd 100644
--- a/Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj
+++ b/Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj
@@ -9,10 +9,19 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>OpenTK.OpenGL</RootNamespace>
     <AssemblyName>OpenTK.OpenGL</AssemblyName>
+    <AllowUnsafeBlocks>False</AllowUnsafeBlocks>
+    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
+    <NoStdLib>False</NoStdLib>
+    <RegisterForComInterop>False</RegisterForComInterop>
+    <GenerateSerializationAssemblies>Auto</GenerateSerializationAssemblies>
+    <BaseAddress>4194304</BaseAddress>
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <FileAlignment>4096</FileAlignment>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
+    <DebugType>Full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>..\..\..\Binaries\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
@@ -43,15 +52,13 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Bindings\GLContextLoad.cs" />
     <Compile Include="Bindings\GL.cs" />
-    <Compile Include="Bindings\WindowsContextLoad.cs" />
-    <Compile Include="Bindings\WindowsVistaContextLoad.cs" />
-    <Compile Include="Bindings\X11ContextLoad.cs" />
+    <Compile Include="Bindings\GLEnums.cs" />
     <Compile Include="Contexts\WindowsBaseContext.cs" />
     <Compile Include="Contexts\WindowsVistaContext.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="GL.cs" />
     <Compile Include="Glu.cs" />
     <Compile Include="Contexts\GLContext.cs" />
     <Compile Include="Contexts\WindowsContext.cs" />
@@ -70,5 +77,8 @@
       <Name>OpenTK.Platform.X</Name>
     </ProjectReference>
   </ItemGroup>
-  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <ItemGroup>
+    <Folder Include="Documentation\" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
 </Project>
\ No newline at end of file
diff --git a/Source/Platform/X/XApi.cs b/Source/Platform/X/XApi.cs
index c6aa38e5..c9fac7e0 100644
--- a/Source/Platform/X/XApi.cs
+++ b/Source/Platform/X/XApi.cs
@@ -22,20 +22,19 @@ namespace OpenTK.Platform.X
             public const int QueuedAfterFlush = 2;
         }
 
-
         [StructLayout(LayoutKind.Sequential)]
         public struct VisualInfo
         {
-            IntPtr visual;
-            int visualid;
-            int screen;
-            uint depth;
-            int @class;
-            ulong red_mask;
-            ulong green_mask;
-            ulong blue_mask;
-            int colormap_size;
-            int bits_per_rgb;
+            public IntPtr visual;
+            public int visualid;
+            public int screen;
+            public uint depth;
+            public int @class;
+            public ulong red_mask;
+            public ulong green_mask;
+            public ulong blue_mask;
+            public int colormap_size;
+            public int bits_per_rgb;
         }
 
         #region Functions
@@ -49,6 +48,9 @@ namespace OpenTK.Platform.X
 
         //
 
+        [DllImport("libX11", EntryPoint = "XCreateColormap")]
+        extern public static IntPtr CreateColormap(IntPtr display, IntPtr window, IntPtr visual, int alloc);
+
         [DllImport(_dll_name, EntryPoint = "XDefaultScreen")]
         extern public static int DefaultScreen(IntPtr display);
 
diff --git a/Specifications/TypeMap.txt b/Specifications/TypeMap.txt
deleted file mode 100644
index b59f27aa..00000000
--- a/Specifications/TypeMap.txt
+++ /dev/null
@@ -1,289 +0,0 @@
-#AccumOp,*,*,			    GLenum,*,*
-#AlphaFunction,*,*,		    GLenum,*,*
-#AttribMask,*,*,			    GLbitfield,*,*
-#BeginMode,*,*,			    GLenum,*,*
-#BinormalPointerTypeEXT,*,*,	    GLenum,*,*
-!BlendEquationMode,*,*,		    GLenum,*,*
-#BlendEquationModeEXT,*,*,	    GLenum,*,*
-!BlendFuncSeparateParameterEXT,*,*,  GLenum,*,*
-#BlendingFactorDest,*,*,		    GLenum,*,*
-#BlendingFactorSrc,*,*,		    GLenum,*,*
-#Boolean,*,*,			    GLboolean,*,*
-#BooleanPointer,*,*,		    GLboolean*,*,*
-#Char,*,*,			    GLchar,*,*
-#CharPointer,*,*,		    GLchar*,*,*
-#CheckedFloat32,*,*,		    GLfloat,*,*
-#CheckedInt32,*,*,		    GLint,*,*
-!ClampColorTargetARB,*,*,	    GLenum,*,*
-!ClampColorModeARB,*,*,		    GLenum,*,*
-#ClampedColorF,*,*,		    GLclampf,*,*
-#ClampedFloat32,*,*,		    GLclampf,*,*
-#ClampedFloat64,*,*,		    GLclampd,*,*
-#ClampedStencilValue,*,*,	    GLint,*,*
-#ClearBufferMask,*,*,		    GLbitfield,*,*
-#ClientAttribMask,*,*,		    GLbitfield,*,*
-#ClipPlaneName,*,*,		    GLenum,*,*
-#ColorB,*,*,			    GLbyte,*,*
-#ColorD,*,*,			    GLdouble,*,*
-#ColorF,*,*,			    GLfloat,*,*
-#ColorI,*,*,			    GLint,*,*
-#ColorIndexValueD,*,*,		    GLdouble,*,*
-#ColorIndexValueF,*,*,		    GLfloat,*,*
-#ColorIndexValueI,*,*,		    GLint,*,*
-#ColorIndexValueS,*,*,		    GLshort,*,*
-#ColorIndexValueUB,*,*,		    GLubyte,*,*
-#ColorMaterialParameter,*,*,	    GLenum,*,*
-#ColorPointerType,*,*,		    GLenum,*,*
-#ColorS,*,*,			    GLshort,*,*
-!ColorTableParameterPName,*,*,	    GLenum,*,*
-#ColorTableParameterPNameSGI,*,*,    GLenum,*,*
-!ColorTableTarget,*,*,		    GLenum,*,*
-#ColorTableTargetSGI,*,*,	    GLenum,*,*
-#ColorUB,*,*,			    GLubyte,*,*
-#ColorUI,*,*,			    GLuint,*,*
-#ColorUS,*,*,			    GLushort,*,*
-#CombinerBiasNV,*,*,		    GLenum,*,*
-#CombinerComponentUsageNV,*,*,	    GLenum,*,*
-#CombinerMappingNV,*,*,		    GLenum,*,*
-#CombinerParameterNV,*,*,	    GLenum,*,*
-#CombinerPortionNV,*,*,		    GLenum,*,*
-#CombinerRegisterNV,*,*,		    GLenum,*,*
-#CombinerScaleNV,*,*,		    GLenum,*,*
-#CombinerStageNV,*,*,		    GLenum,*,*
-#CombinerVariableNV,*,*,		    GLenum,*,*
-#CompressedTextureARB,*,*,	    GLvoid,*,*
-#ControlPointNV,*,*,		    GLvoid,*,*
-#ControlPointTypeNV,*,*,		    GLenum,*,*
-!ConvolutionParameter,*,*,	    GLenum,*,*
-#ConvolutionParameterEXT,*,*,	    GLenum,*,*
-!ConvolutionTarget,*,*,		    GLenum,*,*
-#ConvolutionTargetEXT,*,*,	    GLenum,*,*
-#CoordD,*,*,			    GLdouble,*,*
-#CoordF,*,*,			    GLfloat,*,*
-#CoordI,*,*,			    GLint,*,*
-#CoordS,*,*,			    GLshort,*,*
-#CullFaceMode,*,*,		    GLenum,*,*
-!CullParameterEXT,*,*,		    GLenum,*,*
-#DepthFunction,*,*,		    GLenum,*,*
-#DrawBufferMode,*,*,		    GLenum,*,*
-!DrawElementsType,*,*,		    GLenum,*,*
-#ElementPointerTypeATI,*,*,	    GLenum,*,*
-#EnableCap,*,*,			    GLenum,*,*
-#ErrorCode,*,*,			    GLenum,*,*
-#EvalMapsModeNV,*,*,		    GLenum,*,*
-#EvalTargetNV,*,*,		    GLenum,*,*
-#FeedbackElement,*,*,		    GLfloat,*,*
-#FeedbackType,*,*,		    GLenum,*,*
-#FenceNV,*,*,			    GLuint,*,*
-#FenceConditionNV,*,*,		    GLenum,*,*
-#FenceParameterNameNV,*,*,	    GLenum,*,*
-#FfdMaskSGIX,*,*,		    GLbitfield,*,*
-#FfdTargetSGIX,*,*,		    GLenum,*,*
-#Float32,*,*,			    GLfloat,*,*
-#Float32Pointer,*,*,		    GLfloat*,*,*
-#Float64,*,*,			    GLdouble,*,*
-#Float64Pointer,*,*,		    GLdouble*,*,*
-#FogParameter,*,*,		    GLenum,*,*
-!FogPointerTypeEXT,*,*,		    GLenum,*,*
-!FogPointerTypeIBM,*,*,		    GLenum,*,*
-#FragmentLightModelParameterSGIX,*,*,GLenum,*,*
-#FragmentLightNameSGIX,*,*,	    GLenum,*,*
-#FragmentLightParameterSGIX,*,*,     GLenum,*,*
-#FrontFaceDirection,*,*,		    GLenum,*,*
-FunctionPointer,*,*,		    _GLfuncptr,*,*
-#GetColorTableParameterPName,*,*,    GLenum,*,*
-#GetColorTableParameterPNameSGI,*,*, GLenum,*,*
-!GetConvolutionParameterPName,*,*,   GLenum,*,*
-!GetHistogramParameterPName,*,*,     GLenum,*,*
-#GetHistogramParameterPNameEXT,*,*,  GLenum,*,*
-#GetMapQuery,*,*,		    GLenum,*,*
-!GetMinmaxParameterPName,*,*,	    GLenum,*,*
-#GetMinmaxParameterPNameEXT,*,*,     GLenum,*,*
-#GetPName,*,*,			    GLenum,*,*
-#GetPointervPName,*,*,		    GLenum,*,*
-#GetTextureParameter,*,*,	    GLenum,*,*
-#HintMode,*,*,			    GLenum,*,*
-#HintTarget,*,*,			    GLenum,*,*
-!HintTargetPGI,*,*,		    GLenum,*,*
-!HistogramTarget,*,*,		    GLenum,*,*
-#HistogramTargetEXT,*,*,		    GLenum,*,*
-#IglooFunctionSelectSGIX,*,*,	    GLenum,*,*
-IglooParameterSGIX,*,*,		    GLvoid,*,*
-!ImageTransformPNameHP,*,*,	    GLenum,*,*
-!ImageTransformTargetHP,*,*,	    GLenum,*,*
-!IndexFunctionEXT,*,*,		    GLenum,*,*
-!IndexMaterialParameterEXT,*,*,	    GLenum,*,*
-#IndexPointerType,*,*,		    GLenum,*,*
-#Int16,*,*,			    GLshort,*,*
-#Int32,*,*,			    GLint,*,*
-#Int8,*,*,			    GLbyte,*,*
-#InterleavedArrayFormat,*,*,	    GLenum,*,*
-#LightEnvParameterSGIX,*,*,	    GLenum,*,*
-#LightModelParameter,*,*,	    GLenum,*,*
-#LightName,*,*,			    GLenum,*,*
-#LightParameter,*,*,		    GLenum,*,*
-#LightTextureModeEXT,*,*,	    GLenum,*,*
-#LightTexturePNameEXT,*,*,	    GLenum,*,*
-#LineStipple,*,*,		    GLushort,*,*
-#List,*,*,			    GLuint,*,*
-#ListMode,*,*,			    GLenum,*,*
-#ListNameType,*,*,		    GLenum,*,*
-#ListParameterName,*,*,		    GLenum,*,*
-#LogicOp,*,*,			    GLenum,*,*
-#MapAttribParameterNV,*,*,	    GLenum,*,*
-#MapParameterNV,*,*,		    GLenum,*,*
-#MapTarget,*,*,			    GLenum,*,*
-#MapTargetNV,*,*,		    GLenum,*,*
-#MapTypeNV,*,*,			    GLenum,*,*
-#MaskedColorIndexValueF,*,*,	    GLfloat,*,*
-#MaskedColorIndexValueI,*,*,	    GLuint,*,*
-#MaskedStencilValue,*,*,		    GLuint,*,*
-#MaterialFace,*,*,		    GLenum,*,*
-#MaterialParameter,*,*,		    GLenum,*,*
-!MatrixIndexPointerTypeARB,*,*,	    GLenum,*,*
-#MatrixMode,*,*,			    GLenum,*,*
-#MatrixTransformNV,*,*,		    GLenum,*,*
-#MeshMode1,*,*,			    GLenum,*,*
-#MeshMode2,*,*,			    GLenum,*,*
-!MinmaxTarget,*,*,		    GLenum,*,*
-#MinmaxTargetEXT,*,*,		    GLenum,*,*
-#NormalPointerType,*,*,		    GLenum,*,*
-#NurbsCallback,*,*,		    GLenum,*,*
-NurbsObj,*,*,			    GLUnurbs*,*,*
-#NurbsProperty,*,*,		    GLenum,*,*
-#NurbsTrim,*,*,			    GLenum,*,*
-#OcclusionQueryParameterNameNV,*,*,  GLenum,*,*
-#PixelCopyType,*,*,		    GLenum,*,*
-#PixelFormat,*,*,		    GLenum,*,*
-#PixelInternalFormat,*,*,	    GLenum,*,*
-#PixelMap,*,*,			    GLenum,*,*
-#PixelStoreParameter,*,*,	    GLenum,*,*
-#PixelTexGenModeSGIX,*,*,	    GLenum,*,*
-#PixelTexGenParameterNameSGIS,*,*,   GLenum,*,*
-#PixelTransferParameter,*,*,	    GLenum,*,*
-#PixelTransformPNameEXT,*,*,	    GLenum,*,*
-#PixelTransformTargetEXT,*,*,	    GLenum,*,*
-#PixelType,*,*,			    GLenum,*,*
-!PointParameterNameARB,*,*,	    GLenum,*,*
-#PolygonMode,*,*,		    GLenum,*,*
-ProgramNV,*,*,			    GLuint,*,*
-ProgramCharacterNV,*,*,		    GLubyte,*,*
-#ProgramParameterNV,*,*,		    GLenum,*,*
-#QuadricCallback,*,*,		    GLenum,*,*
-#QuadricDrawStyle,*,*,		    GLenum,*,*
-#QuadricNormal,*,*,		    GLenum,*,*
-QuadricObj,*,*,			    GLUquadric*,*,*
-#QuadricOrientation,*,*,		    GLenum,*,*
-#ReadBufferMode,*,*,		    GLenum,*,*
-#RenderingMode,*,*,		    GLenum,*,*
-ReplacementCodeSUN,*,*,		    GLuint,*,*
-#ReplacementCodeTypeSUN,*,*,	    GLenum,*,*
-#SamplePassARB,*,*,		    GLenum,*,*
-#SamplePatternEXT,*,*,		    GLenum,*,*
-#SamplePatternSGIS,*,*,		    GLenum,*,*
-#SecondaryColorPointerTypeIBM,*,*,   GLenum,*,*
-#SelectName,*,*,			    GLuint,*,*
-!SeparableTarget,*,*,		    GLenum,*,*
-#SeparableTargetEXT,*,*,		    GLenum,*,*
-#ShadingModel,*,*,		    GLenum,*,*
-#SizeI,*,*,			    GLsizei,*,*
-#SpriteParameterNameSGIX,*,*,	    GLenum,*,*
-#StencilFunction,*,*,		    GLenum,*,*
-!StencilFaceDirection,*,*,	    GLenum,*,*
-#StencilOp,*,*,			    GLenum,*,*
-#StencilValue,*,*,		    GLint,*,*
-#String,*,*,			    GLstring,*,*
-#StringName,*,*,			    GLenum,*,*
-#TangentPointerTypeEXT,*,*,	    GLenum,*,*
-#TessCallback,*,*,		    GLenum,*,*
-#TessContour,*,*,		    GLenum,*,*
-#TessProperty,*,*,		    GLenum,*,*
-TesselatorObj,*,*,		    GLUtesselator*,*,*
-#TexCoordPointerType,*,*,	    GLenum,*,*
-#Texture,*,*,			    GLuint,*,*
-#TextureComponentCount,*,*,	    GLint,*,*
-#TextureCoordName,*,*,		    GLenum,*,*
-#TextureEnvParameter,*,*,	    GLenum,*,*
-#TextureEnvTarget,*,*,		    GLenum,*,*
-!TextureFilterSGIS,*,*,		    GLenum,*,*
-#TextureGenParameter,*,*,	    GLenum,*,*
-#TextureNormalModeEXT,*,*,	    GLenum,*,*
-#TextureParameterName,*,*,	    GLenum,*,*
-#TextureTarget,*,*,		    GLenum,*,*
-!TextureUnit,*,*,		    GLenum,*,*
-#UInt16,*,*,			    GLushort,*,*
-#UInt32,*,*,			    GLuint,*,*
-#UInt8,*,*,			    GLubyte,*,*
-#VertexAttribEnumNV,*,*,		    GLenum,*,*
-#VertexAttribPointerTypeNV,*,*,	    GLenum,*,*
-#VertexPointerType,*,*,		    GLenum,*,*
-#VertexWeightPointerTypeEXT,*,*,     GLenum,*,*
-#Void,*,*,			    GLvoid,*,*
-VoidPointer,*,*,		    GLvoid*,*,*
-#ConstVoidPointer,*,*,		    GLvoid* const,*,*
-!WeightPointerTypeARB,*,*,	    GLenum,*,*
-#WinCoord,*,*,			    GLint,*,*
-#void,*,*,			    *,*,*
-#ArrayObjectPNameATI,*,*,	    GLenum,*,*
-#ArrayObjectUsageATI,*,*,	    GLenum,*,*,
-ConstFloat32,*,*,		    GLfloat,*,*
-ConstInt32,*,*,			    GLint,*,*
-ConstUInt32,*,*,		    GLuint,*,*
-ConstVoid,*,*,			    GLvoid,*,*
-#DataTypeEXT,*,*,		    GLenum,*,*
-#FragmentOpATI,*,*,		    GLenum,*,*
-#GetTexBumpParameterATI,*,*,	    GLenum,*,*
-#GetVariantValueEXT,*,*,		    GLenum,*,*
-#ParameterRangeEXT,*,*,		    GLenum,*,*
-#PreserveModeATI,*,*,		    GLenum,*,*
-!ProgramFormatARB,*,*,		    GLenum,*,*
-!ProgramTargetARB,*,*,		    GLenum,*,*
-!ProgramPropertyARB,*,*,		    GLenum,*,*
-!ProgramStringPropertyARB,*,*,	    GLenum,*,*
-#ScalarType,*,*,			    GLenum,*,*
-#SwizzleOpATI,*,*,		    GLenum,*,*
-#TexBumpParameterATI,*,*,	    GLenum,*,*
-#VariantCapEXT,*,*,		    GLenum,*,*
-!VertexAttribPointerPropertyARB,*,*, GLenum,*,*
-!VertexAttribPointerTypeARB,*,*,     GLenum,*,*
-!VertexAttribPropertyARB,*,*,	    GLenum,*,*
-#VertexShaderCoordOutEXT,*,*,	    GLenum,*,*
-#VertexShaderOpEXT,*,*,		    GLenum,*,*
-#VertexShaderParameterEXT,*,*,	    GLenum,*,*
-#VertexShaderStorageTypeEXT,*,*,     GLenum,*,*
-#VertexShaderTextureUnitParameter,*,*,	GLenum,*,*
-#VertexShaderWriteMaskEXT,*,*,	    GLenum,*,*
-#VertexStreamATI,*,*,		    GLenum,*,*
-#PNTrianglesPNameATI,*,*,	    GLenum,*,*
-
-# ARB_vertex_buffer_object types and core equivalents for new types
-VertexBufferOffset,*,*,		    GLintptr,*,*
-#VertexBufferSize,*,*,		    GLsizeiptr,*,*
-!VertexBufferAccessARB,*,*,	    GLenum,*,*
-#VertexBufferOffsetARB,*,*,	    GLintptrARB,*,*
-!VertexBufferPNameARB,*,*,	    GLenum,*,*
-!VertexBufferPointerNameARB,*,*,     GLenum,*,*
-VertexBufferSizeARB,*,*,	    GLsizeiptrARB,*,*
-!VertexBufferTargetARB,*,*,	    GLenum,*,*
-!VertexBufferUsageARB,*,*,	    GLenum,*,*
-
-# APPLE_fence
-#ObjectTypeAPPLE,*,*,		    GLenum,*,*
-
-# APPLE_vertex_array_range
-#VertexArrayPNameAPPLE,*,*,	    GLenum,*,*
-
-# ATI_draw_buffers
-!DrawBufferModeATI,*,*,		    GLenum,*,*
-
-# NV_half
-#Half16NV,*,*,			    GLhalfNV,*,*
-
-# NV_pixel_data_range
-#PixelDataRangeTargetNV,*,*,	    GLenum,*,*
-
-# Generic types for as-yet-unspecified enums
-!GLenum,*,*,			    GLenum,*,*
-#handleARB,*,*,			    GLhandleARB,*,*
-#charARB,*,*,			    GLcharARB,*,*
-#charPointerARB,*,*,		    GLcharARB*,*,*
\ No newline at end of file
diff --git a/changelog.txt b/changelog.txt
index f03f7325..81518b57 100644
--- a/changelog.txt
+++ b/changelog.txt
@@ -1,3 +1,14 @@
+OpenTK 0.3.6
+
+
+OpenTK 0.3.5 -> 0.3.6
++ Updates to OpenTK.OpenGL.Bind (see that changelog for more info).
+	+ Revamped GL class (is self contained)
+	+ Revamped GLContext class (it is no longer bound to the GL class initialisation).
++ Directory structure updates (Documentation folder for each project, plus main Documentation folder)
++ Framework updates (cleaner implementation, new namespace).
+
+
 OpenTK 0.3.4 -> 0.3.5
 + Major update to OpenTK.OpenGL.Bind (cleaner code, new functions, comments and many new wrappers).
 + Updated the spec files for opengl 2.1.
@@ -16,6 +27,7 @@ OpenTK 0.3.4 -> 0.3.5
 	+ The Framework now resides in its own project directory.
 + Revamped the GLContext class hierarchy. WindowsContext and WindowsVistaContext now both inherit from WindowsBaseContext. This allows for less code-duplication (and thus less bugs).
 
+
 OpenTK 0.3.3 -> 0.3.4
 + Corrected the crash error in Release mode (it was caused by trying to Marshal the System.Windows.Forms.Message struct to PeekMessage - adding my own Message struct corrected the issue).
 + Corrected the call to glShaderSource GLSL.Lesson01. Now the correct number is passed to the count parameter, while the null parameter was changed to IntPtr.Zero (Mono now no longers fails in this call).
@@ -23,18 +35,21 @@ OpenTK 0.3.3 -> 0.3.4
 + OpenTK.OpenGL.Bind 0.7.5.1 -> 0.7.5.2 (see Bind changelog for more information)
 + Full Mono support under windows.
 
+
 OpenTK 0.3.2 -> 0.3.3
 + OpenTK.OpenGL.Bind 0.7.5 -> 0.7.5.1 (see Bind changelog for more information)
 + Added the GLForm class which sets the base for cross-platform screen, context and keyboard handling.
 + Can now change between fullscreen and windowed modes.
 + Temporarily removed all examples except for GLSL.Lesson01, which has been updated to use the new GLForm class.
 
+
 OpenTK 0.3.1 -> 0.3.2
 + OpenTK.OpenGL.Glu: Eliminated the temporary IntPtr variable in the GetString and ErrorString functions.
 + Specifications.cs_types.txt: Changed types in order to be CLS compliant.
 + OpenTK.OpenGL.Bind 0.7.4 -> 0.7.5
 + Added the GLSL.Lesson01 example.
 
+
 OpenTK 0.3.0 -> 0.3.1
 + Updated the binding generator to version 0.7.4, based on the work done for Tao.
 + Updated the Context load functions. Now Context loads all functions are extensions, and the derived classes override this behavior as needed.
diff --git a/todo.txt b/todo.txt
index ff038c4e..e75c2d76 100644
--- a/todo.txt
+++ b/todo.txt
@@ -1,13 +1,16 @@
 Todo:
++ + + Update directory structure (specs shouldn't reside in the top directory)
++ + + Fully implement Framework class.
 + + + Correct the Dispose methods to correctly clean resources (they should also call GC.SupressFinalize(true))
 + + + Add basic GLX bindings	(in progress)
 + + + Add basic X bindings		(in progress)
-+ + + Add context creation support for X	(needs testing)
++ + + Add context creation support for X	(needs fixing)
 + + + Test X support.
 + + + Add the CLS compliant attribute to the GL class.
++ + + Clean up the build system for windows .Net, and add build system for linux Mono and windows Mono.
++ + Add docs to each project.
 + + Add cross-platform way for defining the Application.Idle handler	(needs testing)
 + + Add more constructors to the Context classes.
-+ + Add more Framework constructors.
 + + Add comments and documentation (faqs, pitfalls, best practices).
 + + Add a cross-platform build system (probably NAnt?)
 + Add more examples.