#region License
//
// The Open Toolkit Library License
//
// Copyright (c) 2006 - 2009 the Open Toolkit library.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights to 
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do
// so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//
#endregion

namespace Tao.OpenGl
{
    using System;
    using System.Runtime.InteropServices;

#pragma warning disable 3019
#pragma warning disable 1591

    public static partial class Gl
    {
        [System.CLSCompliant(false)]
        public static 
        void glNewList(UInt32 list, int mode)
        {
            Delegates.glNewList((UInt32)list, (int)mode);
        }

        public static 
        void glNewList(Int32 list, int mode)
        {
            Delegates.glNewList((UInt32)list, (int)mode);
        }

        public static 
        void glEndList()
        {
            Delegates.glEndList();
        }

        [System.CLSCompliant(false)]
        public static 
        void glCallList(UInt32 list)
        {
            Delegates.glCallList((UInt32)list);
        }

        public static 
        void glCallList(Int32 list)
        {
            Delegates.glCallList((UInt32)list);
        }

        public static 
        void glCallLists(Int32 n, int type, IntPtr lists)
        {
            unsafe
            {
                Delegates.glCallLists((Int32)n, (int)type, (IntPtr)lists);
            }
        }

        public static 
        void glCallLists(Int32 n, int type, [In, Out] object lists)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle lists_ptr = System.Runtime.InteropServices.GCHandle.Alloc(lists, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCallLists((Int32)n, (int)type, (IntPtr)lists_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    lists_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteLists(UInt32 list, Int32 range)
        {
            Delegates.glDeleteLists((UInt32)list, (Int32)range);
        }

        public static 
        void glDeleteLists(Int32 list, Int32 range)
        {
            Delegates.glDeleteLists((UInt32)list, (Int32)range);
        }

        public static 
        Int32 glGenLists(Int32 range)
        {
            return Delegates.glGenLists((Int32)range);
        }

        [System.CLSCompliant(false)]
        public static 
        void glListBase(UInt32 @base)
        {
            Delegates.glListBase((UInt32)@base);
        }

        public static 
        void glListBase(Int32 @base)
        {
            Delegates.glListBase((UInt32)@base);
        }

        public static 
        void glBegin(int mode)
        {
            Delegates.glBegin((int)mode);
        }

        public static 
        void glBitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, IntPtr bitmap)
        {
            unsafe
            {
                Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap);
            }
        }

        public static 
        void glBitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, Byte[] bitmap)
        {
            unsafe
            {
                fixed (Byte* bitmap_ptr = bitmap)
                {
                    Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap_ptr);
                }
            }
        }

        public static 
        void glBitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, ref Byte bitmap)
        {
            unsafe
            {
                fixed (Byte* bitmap_ptr = &bitmap)
                {
                    Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3b(SByte red, SByte green, SByte blue)
        {
            Delegates.glColor3b((SByte)red, (SByte)green, (SByte)blue);
        }

        public static 
        void glColor3b(Byte red, Byte green, Byte blue)
        {
            Delegates.glColor3b((SByte)red, (SByte)green, (SByte)blue);
        }

        public static 
        void glColor3bv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3bv((SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3bv(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glColor3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glColor3bv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glColor3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3bv(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glColor3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glColor3bv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glColor3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glColor3d(Double red, Double green, Double blue)
        {
            Delegates.glColor3d((Double)red, (Double)green, (Double)blue);
        }

        public static 
        void glColor3dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3dv((Double*)v);
            }
        }

        public static 
        void glColor3dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glColor3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glColor3dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glColor3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glColor3f(Single red, Single green, Single blue)
        {
            Delegates.glColor3f((Single)red, (Single)green, (Single)blue);
        }

        public static 
        void glColor3fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3fv((Single*)v);
            }
        }

        public static 
        void glColor3fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor3fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor3i(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glColor3i((Int32)red, (Int32)green, (Int32)blue);
        }

        public static 
        void glColor3iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3iv((Int32*)v);
            }
        }

        public static 
        void glColor3iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glColor3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glColor3iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glColor3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glColor3s(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glColor3s((Int16)red, (Int16)green, (Int16)blue);
        }

        public static 
        void glColor3sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3sv((Int16*)v);
            }
        }

        public static 
        void glColor3sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glColor3sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glColor3ub(Byte red, Byte green, Byte blue)
        {
            Delegates.glColor3ub((Byte)red, (Byte)green, (Byte)blue);
        }

        public static 
        void glColor3ubv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3ubv((Byte*)v);
            }
        }

        public static 
        void glColor3ubv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glColor3ubv((Byte*)v_ptr);
                }
            }
        }

        public static 
        void glColor3ubv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glColor3ubv((Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3ui(UInt32 red, UInt32 green, UInt32 blue)
        {
            Delegates.glColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        public static 
        void glColor3ui(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        public static 
        void glColor3uiv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3uiv((UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3uiv(UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glColor3uiv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3uiv(ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glColor3uiv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3us(UInt16 red, UInt16 green, UInt16 blue)
        {
            Delegates.glColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glColor3us(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glColor3usv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3usv((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3usv(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glColor3usv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor3usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3usv(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glColor3usv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor3usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4b(SByte red, SByte green, SByte blue, SByte alpha)
        {
            Delegates.glColor4b((SByte)red, (SByte)green, (SByte)blue, (SByte)alpha);
        }

        public static 
        void glColor4b(Byte red, Byte green, Byte blue, Byte alpha)
        {
            Delegates.glColor4b((SByte)red, (SByte)green, (SByte)blue, (SByte)alpha);
        }

        public static 
        void glColor4bv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4bv((SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4bv(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glColor4bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glColor4bv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glColor4bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4bv(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glColor4bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glColor4bv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glColor4bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glColor4d(Double red, Double green, Double blue, Double alpha)
        {
            Delegates.glColor4d((Double)red, (Double)green, (Double)blue, (Double)alpha);
        }

        public static 
        void glColor4dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4dv((Double*)v);
            }
        }

        public static 
        void glColor4dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glColor4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glColor4dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glColor4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glColor4f(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glColor4f((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void glColor4fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4fv((Single*)v);
            }
        }

        public static 
        void glColor4fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4i(Int32 red, Int32 green, Int32 blue, Int32 alpha)
        {
            Delegates.glColor4i((Int32)red, (Int32)green, (Int32)blue, (Int32)alpha);
        }

        public static 
        void glColor4iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4iv((Int32*)v);
            }
        }

        public static 
        void glColor4iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glColor4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glColor4iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glColor4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glColor4s(Int16 red, Int16 green, Int16 blue, Int16 alpha)
        {
            Delegates.glColor4s((Int16)red, (Int16)green, (Int16)blue, (Int16)alpha);
        }

        public static 
        void glColor4sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4sv((Int16*)v);
            }
        }

        public static 
        void glColor4sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glColor4sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ub(Byte red, Byte green, Byte blue, Byte alpha)
        {
            Delegates.glColor4ub((Byte)red, (Byte)green, (Byte)blue, (Byte)alpha);
        }

        public static 
        void glColor4ubv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4ubv((Byte*)v);
            }
        }

        public static 
        void glColor4ubv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glColor4ubv((Byte*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glColor4ubv((Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4ui(UInt32 red, UInt32 green, UInt32 blue, UInt32 alpha)
        {
            Delegates.glColor4ui((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
        }

        public static 
        void glColor4ui(Int32 red, Int32 green, Int32 blue, Int32 alpha)
        {
            Delegates.glColor4ui((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
        }

        public static 
        void glColor4uiv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4uiv((UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4uiv(UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glColor4uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glColor4uiv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glColor4uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4uiv(ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glColor4uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glColor4uiv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glColor4uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4us(UInt16 red, UInt16 green, UInt16 blue, UInt16 alpha)
        {
            Delegates.glColor4us((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
        }

        public static 
        void glColor4us(Int16 red, Int16 green, Int16 blue, Int16 alpha)
        {
            Delegates.glColor4us((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
        }

        public static 
        void glColor4usv(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4usv((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4usv(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glColor4usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glColor4usv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor4usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4usv(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glColor4usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glColor4usv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor4usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glEdgeFlag(Int32 flag)
        {
            Delegates.glEdgeFlag((Int32)flag);
        }

        public static 
        void glEdgeFlagv(IntPtr flag)
        {
            unsafe
            {
                Delegates.glEdgeFlagv((Int32*)flag);
            }
        }

        public static 
        void glEdgeFlagv(Int32[] flag)
        {
            unsafe
            {
                fixed (Int32* flag_ptr = flag)
                {
                    Delegates.glEdgeFlagv((Int32*)flag_ptr);
                }
            }
        }

        public static 
        void glEdgeFlagv(ref Int32 flag)
        {
            unsafe
            {
                fixed (Int32* flag_ptr = &flag)
                {
                    Delegates.glEdgeFlagv((Int32*)flag_ptr);
                }
            }
        }

        public static 
        void glEnd()
        {
            Delegates.glEnd();
        }

        public static 
        void glIndexd(Double c)
        {
            Delegates.glIndexd((Double)c);
        }

        public static 
        void glIndexdv(IntPtr c)
        {
            unsafe
            {
                Delegates.glIndexdv((Double*)c);
            }
        }

        public static 
        void glIndexdv(Double[] c)
        {
            unsafe
            {
                fixed (Double* c_ptr = c)
                {
                    Delegates.glIndexdv((Double*)c_ptr);
                }
            }
        }

        public static 
        void glIndexdv(ref Double c)
        {
            unsafe
            {
                fixed (Double* c_ptr = &c)
                {
                    Delegates.glIndexdv((Double*)c_ptr);
                }
            }
        }

        public static 
        void glIndexf(Single c)
        {
            Delegates.glIndexf((Single)c);
        }

        public static 
        void glIndexfv(IntPtr c)
        {
            unsafe
            {
                Delegates.glIndexfv((Single*)c);
            }
        }

        public static 
        void glIndexfv(Single[] c)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glIndexfv((Single*)c_ptr);
                }
            }
        }

        public static 
        void glIndexfv(ref Single c)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glIndexfv((Single*)c_ptr);
                }
            }
        }

        public static 
        void glIndexi(Int32 c)
        {
            Delegates.glIndexi((Int32)c);
        }

        public static 
        void glIndexiv(IntPtr c)
        {
            unsafe
            {
                Delegates.glIndexiv((Int32*)c);
            }
        }

        public static 
        void glIndexiv(Int32[] c)
        {
            unsafe
            {
                fixed (Int32* c_ptr = c)
                {
                    Delegates.glIndexiv((Int32*)c_ptr);
                }
            }
        }

        public static 
        void glIndexiv(ref Int32 c)
        {
            unsafe
            {
                fixed (Int32* c_ptr = &c)
                {
                    Delegates.glIndexiv((Int32*)c_ptr);
                }
            }
        }

        public static 
        void glIndexs(Int16 c)
        {
            Delegates.glIndexs((Int16)c);
        }

        public static 
        void glIndexsv(IntPtr c)
        {
            unsafe
            {
                Delegates.glIndexsv((Int16*)c);
            }
        }

        public static 
        void glIndexsv(Int16[] c)
        {
            unsafe
            {
                fixed (Int16* c_ptr = c)
                {
                    Delegates.glIndexsv((Int16*)c_ptr);
                }
            }
        }

        public static 
        void glIndexsv(ref Int16 c)
        {
            unsafe
            {
                fixed (Int16* c_ptr = &c)
                {
                    Delegates.glIndexsv((Int16*)c_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormal3b(SByte nx, SByte ny, SByte nz)
        {
            Delegates.glNormal3b((SByte)nx, (SByte)ny, (SByte)nz);
        }

        public static 
        void glNormal3b(Byte nx, Byte ny, Byte nz)
        {
            Delegates.glNormal3b((SByte)nx, (SByte)ny, (SByte)nz);
        }

        public static 
        void glNormal3bv(IntPtr v)
        {
            unsafe
            {
                Delegates.glNormal3bv((SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormal3bv(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glNormal3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3bv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glNormal3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormal3bv(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glNormal3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3bv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glNormal3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3d(Double nx, Double ny, Double nz)
        {
            Delegates.glNormal3d((Double)nx, (Double)ny, (Double)nz);
        }

        public static 
        void glNormal3dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glNormal3dv((Double*)v);
            }
        }

        public static 
        void glNormal3dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glNormal3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glNormal3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3f(Single nx, Single ny, Single nz)
        {
            Delegates.glNormal3f((Single)nx, (Single)ny, (Single)nz);
        }

        public static 
        void glNormal3fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glNormal3fv((Single*)v);
            }
        }

        public static 
        void glNormal3fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glNormal3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glNormal3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3i(Int32 nx, Int32 ny, Int32 nz)
        {
            Delegates.glNormal3i((Int32)nx, (Int32)ny, (Int32)nz);
        }

        public static 
        void glNormal3iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glNormal3iv((Int32*)v);
            }
        }

        public static 
        void glNormal3iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glNormal3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glNormal3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3s(Int16 nx, Int16 ny, Int16 nz)
        {
            Delegates.glNormal3s((Int16)nx, (Int16)ny, (Int16)nz);
        }

        public static 
        void glNormal3sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glNormal3sv((Int16*)v);
            }
        }

        public static 
        void glNormal3sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glNormal3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glNormal3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos2d(Double x, Double y)
        {
            Delegates.glRasterPos2d((Double)x, (Double)y);
        }

        public static 
        void glRasterPos2dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos2dv((Double*)v);
            }
        }

        public static 
        void glRasterPos2dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glRasterPos2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos2dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glRasterPos2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos2f(Single x, Single y)
        {
            Delegates.glRasterPos2f((Single)x, (Single)y);
        }

        public static 
        void glRasterPos2fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos2fv((Single*)v);
            }
        }

        public static 
        void glRasterPos2fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glRasterPos2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos2fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glRasterPos2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos2i(Int32 x, Int32 y)
        {
            Delegates.glRasterPos2i((Int32)x, (Int32)y);
        }

        public static 
        void glRasterPos2iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos2iv((Int32*)v);
            }
        }

        public static 
        void glRasterPos2iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glRasterPos2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos2iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glRasterPos2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos2s(Int16 x, Int16 y)
        {
            Delegates.glRasterPos2s((Int16)x, (Int16)y);
        }

        public static 
        void glRasterPos2sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos2sv((Int16*)v);
            }
        }

        public static 
        void glRasterPos2sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glRasterPos2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos2sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glRasterPos2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos3d(Double x, Double y, Double z)
        {
            Delegates.glRasterPos3d((Double)x, (Double)y, (Double)z);
        }

        public static 
        void glRasterPos3dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos3dv((Double*)v);
            }
        }

        public static 
        void glRasterPos3dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glRasterPos3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos3dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glRasterPos3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos3f(Single x, Single y, Single z)
        {
            Delegates.glRasterPos3f((Single)x, (Single)y, (Single)z);
        }

        public static 
        void glRasterPos3fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos3fv((Single*)v);
            }
        }

        public static 
        void glRasterPos3fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glRasterPos3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos3fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glRasterPos3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos3i(Int32 x, Int32 y, Int32 z)
        {
            Delegates.glRasterPos3i((Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void glRasterPos3iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos3iv((Int32*)v);
            }
        }

        public static 
        void glRasterPos3iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glRasterPos3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos3iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glRasterPos3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos3s(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glRasterPos3s((Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glRasterPos3sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos3sv((Int16*)v);
            }
        }

        public static 
        void glRasterPos3sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glRasterPos3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos3sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glRasterPos3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos4d(Double x, Double y, Double z, Double w)
        {
            Delegates.glRasterPos4d((Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glRasterPos4dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos4dv((Double*)v);
            }
        }

        public static 
        void glRasterPos4dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glRasterPos4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos4dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glRasterPos4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos4f(Single x, Single y, Single z, Single w)
        {
            Delegates.glRasterPos4f((Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glRasterPos4fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos4fv((Single*)v);
            }
        }

        public static 
        void glRasterPos4fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glRasterPos4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos4fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glRasterPos4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos4i(Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glRasterPos4i((Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void glRasterPos4iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos4iv((Int32*)v);
            }
        }

        public static 
        void glRasterPos4iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glRasterPos4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos4iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glRasterPos4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos4s(Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glRasterPos4s((Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void glRasterPos4sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glRasterPos4sv((Int16*)v);
            }
        }

        public static 
        void glRasterPos4sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glRasterPos4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glRasterPos4sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glRasterPos4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glRectd(Double x1, Double y1, Double x2, Double y2)
        {
            Delegates.glRectd((Double)x1, (Double)y1, (Double)x2, (Double)y2);
        }

        public static 
        void glRectdv(IntPtr v1, IntPtr v2)
        {
            unsafe
            {
                Delegates.glRectdv((Double*)v1, (Double*)v2);
            }
        }

        public static 
        void glRectdv(IntPtr v1, Double[] v2)
        {
            unsafe
            {
                fixed (Double* v2_ptr = v2)
                {
                    Delegates.glRectdv((Double*)v1, (Double*)v2_ptr);
                }
            }
        }

        public static 
        void glRectdv(IntPtr v1, ref Double v2)
        {
            unsafe
            {
                fixed (Double* v2_ptr = &v2)
                {
                    Delegates.glRectdv((Double*)v1, (Double*)v2_ptr);
                }
            }
        }

        public static 
        void glRectdv(Double[] v1, IntPtr v2)
        {
            unsafe
            {
                fixed (Double* v1_ptr = v1)
                {
                    Delegates.glRectdv((Double*)v1_ptr, (Double*)v2);
                }
            }
        }

        public static 
        void glRectdv(Double[] v1, Double[] v2)
        {
            unsafe
            {
                fixed (Double* v1_ptr = v1)
                fixed (Double* v2_ptr = v2)
                {
                    Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
                }
            }
        }

        public static 
        void glRectdv(Double[] v1, ref Double v2)
        {
            unsafe
            {
                fixed (Double* v1_ptr = v1)
                fixed (Double* v2_ptr = &v2)
                {
                    Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
                }
            }
        }

        public static 
        void glRectdv(ref Double v1, IntPtr v2)
        {
            unsafe
            {
                fixed (Double* v1_ptr = &v1)
                {
                    Delegates.glRectdv((Double*)v1_ptr, (Double*)v2);
                }
            }
        }

        public static 
        void glRectdv(ref Double v1, Double[] v2)
        {
            unsafe
            {
                fixed (Double* v1_ptr = &v1)
                fixed (Double* v2_ptr = v2)
                {
                    Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
                }
            }
        }

        public static 
        void glRectdv(ref Double v1, ref Double v2)
        {
            unsafe
            {
                fixed (Double* v1_ptr = &v1)
                fixed (Double* v2_ptr = &v2)
                {
                    Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
                }
            }
        }

        public static 
        void glRectf(Single x1, Single y1, Single x2, Single y2)
        {
            Delegates.glRectf((Single)x1, (Single)y1, (Single)x2, (Single)y2);
        }

        public static 
        void glRectfv(IntPtr v1, IntPtr v2)
        {
            unsafe
            {
                Delegates.glRectfv((Single*)v1, (Single*)v2);
            }
        }

        public static 
        void glRectfv(IntPtr v1, Single[] v2)
        {
            unsafe
            {
                fixed (Single* v2_ptr = v2)
                {
                    Delegates.glRectfv((Single*)v1, (Single*)v2_ptr);
                }
            }
        }

        public static 
        void glRectfv(IntPtr v1, ref Single v2)
        {
            unsafe
            {
                fixed (Single* v2_ptr = &v2)
                {
                    Delegates.glRectfv((Single*)v1, (Single*)v2_ptr);
                }
            }
        }

        public static 
        void glRectfv(Single[] v1, IntPtr v2)
        {
            unsafe
            {
                fixed (Single* v1_ptr = v1)
                {
                    Delegates.glRectfv((Single*)v1_ptr, (Single*)v2);
                }
            }
        }

        public static 
        void glRectfv(Single[] v1, Single[] v2)
        {
            unsafe
            {
                fixed (Single* v1_ptr = v1)
                fixed (Single* v2_ptr = v2)
                {
                    Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
                }
            }
        }

        public static 
        void glRectfv(Single[] v1, ref Single v2)
        {
            unsafe
            {
                fixed (Single* v1_ptr = v1)
                fixed (Single* v2_ptr = &v2)
                {
                    Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
                }
            }
        }

        public static 
        void glRectfv(ref Single v1, IntPtr v2)
        {
            unsafe
            {
                fixed (Single* v1_ptr = &v1)
                {
                    Delegates.glRectfv((Single*)v1_ptr, (Single*)v2);
                }
            }
        }

        public static 
        void glRectfv(ref Single v1, Single[] v2)
        {
            unsafe
            {
                fixed (Single* v1_ptr = &v1)
                fixed (Single* v2_ptr = v2)
                {
                    Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
                }
            }
        }

        public static 
        void glRectfv(ref Single v1, ref Single v2)
        {
            unsafe
            {
                fixed (Single* v1_ptr = &v1)
                fixed (Single* v2_ptr = &v2)
                {
                    Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
                }
            }
        }

        public static 
        void glRecti(Int32 x1, Int32 y1, Int32 x2, Int32 y2)
        {
            Delegates.glRecti((Int32)x1, (Int32)y1, (Int32)x2, (Int32)y2);
        }

        public static 
        void glRectiv(IntPtr v1, IntPtr v2)
        {
            unsafe
            {
                Delegates.glRectiv((Int32*)v1, (Int32*)v2);
            }
        }

        public static 
        void glRectiv(IntPtr v1, Int32[] v2)
        {
            unsafe
            {
                fixed (Int32* v2_ptr = v2)
                {
                    Delegates.glRectiv((Int32*)v1, (Int32*)v2_ptr);
                }
            }
        }

        public static 
        void glRectiv(IntPtr v1, ref Int32 v2)
        {
            unsafe
            {
                fixed (Int32* v2_ptr = &v2)
                {
                    Delegates.glRectiv((Int32*)v1, (Int32*)v2_ptr);
                }
            }
        }

        public static 
        void glRectiv(Int32[] v1, IntPtr v2)
        {
            unsafe
            {
                fixed (Int32* v1_ptr = v1)
                {
                    Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2);
                }
            }
        }

        public static 
        void glRectiv(Int32[] v1, Int32[] v2)
        {
            unsafe
            {
                fixed (Int32* v1_ptr = v1)
                fixed (Int32* v2_ptr = v2)
                {
                    Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
                }
            }
        }

        public static 
        void glRectiv(Int32[] v1, ref Int32 v2)
        {
            unsafe
            {
                fixed (Int32* v1_ptr = v1)
                fixed (Int32* v2_ptr = &v2)
                {
                    Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
                }
            }
        }

        public static 
        void glRectiv(ref Int32 v1, IntPtr v2)
        {
            unsafe
            {
                fixed (Int32* v1_ptr = &v1)
                {
                    Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2);
                }
            }
        }

        public static 
        void glRectiv(ref Int32 v1, Int32[] v2)
        {
            unsafe
            {
                fixed (Int32* v1_ptr = &v1)
                fixed (Int32* v2_ptr = v2)
                {
                    Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
                }
            }
        }

        public static 
        void glRectiv(ref Int32 v1, ref Int32 v2)
        {
            unsafe
            {
                fixed (Int32* v1_ptr = &v1)
                fixed (Int32* v2_ptr = &v2)
                {
                    Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
                }
            }
        }

        public static 
        void glRects(Int16 x1, Int16 y1, Int16 x2, Int16 y2)
        {
            Delegates.glRects((Int16)x1, (Int16)y1, (Int16)x2, (Int16)y2);
        }

        public static 
        void glRectsv(IntPtr v1, IntPtr v2)
        {
            unsafe
            {
                Delegates.glRectsv((Int16*)v1, (Int16*)v2);
            }
        }

        public static 
        void glRectsv(IntPtr v1, Int16[] v2)
        {
            unsafe
            {
                fixed (Int16* v2_ptr = v2)
                {
                    Delegates.glRectsv((Int16*)v1, (Int16*)v2_ptr);
                }
            }
        }

        public static 
        void glRectsv(IntPtr v1, ref Int16 v2)
        {
            unsafe
            {
                fixed (Int16* v2_ptr = &v2)
                {
                    Delegates.glRectsv((Int16*)v1, (Int16*)v2_ptr);
                }
            }
        }

        public static 
        void glRectsv(Int16[] v1, IntPtr v2)
        {
            unsafe
            {
                fixed (Int16* v1_ptr = v1)
                {
                    Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2);
                }
            }
        }

        public static 
        void glRectsv(Int16[] v1, Int16[] v2)
        {
            unsafe
            {
                fixed (Int16* v1_ptr = v1)
                fixed (Int16* v2_ptr = v2)
                {
                    Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
                }
            }
        }

        public static 
        void glRectsv(Int16[] v1, ref Int16 v2)
        {
            unsafe
            {
                fixed (Int16* v1_ptr = v1)
                fixed (Int16* v2_ptr = &v2)
                {
                    Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
                }
            }
        }

        public static 
        void glRectsv(ref Int16 v1, IntPtr v2)
        {
            unsafe
            {
                fixed (Int16* v1_ptr = &v1)
                {
                    Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2);
                }
            }
        }

        public static 
        void glRectsv(ref Int16 v1, Int16[] v2)
        {
            unsafe
            {
                fixed (Int16* v1_ptr = &v1)
                fixed (Int16* v2_ptr = v2)
                {
                    Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
                }
            }
        }

        public static 
        void glRectsv(ref Int16 v1, ref Int16 v2)
        {
            unsafe
            {
                fixed (Int16* v1_ptr = &v1)
                fixed (Int16* v2_ptr = &v2)
                {
                    Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
                }
            }
        }

        public static 
        void glTexCoord1d(Double s)
        {
            Delegates.glTexCoord1d((Double)s);
        }

        public static 
        void glTexCoord1dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord1dv((Double*)v);
            }
        }

        public static 
        void glTexCoord1dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTexCoord1dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTexCoord1dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1f(Single s)
        {
            Delegates.glTexCoord1f((Single)s);
        }

        public static 
        void glTexCoord1fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord1fv((Single*)v);
            }
        }

        public static 
        void glTexCoord1fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord1fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord1fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1i(Int32 s)
        {
            Delegates.glTexCoord1i((Int32)s);
        }

        public static 
        void glTexCoord1iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord1iv((Int32*)v);
            }
        }

        public static 
        void glTexCoord1iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTexCoord1iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTexCoord1iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1s(Int16 s)
        {
            Delegates.glTexCoord1s((Int16)s);
        }

        public static 
        void glTexCoord1sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord1sv((Int16*)v);
            }
        }

        public static 
        void glTexCoord1sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord1sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord1sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2d(Double s, Double t)
        {
            Delegates.glTexCoord2d((Double)s, (Double)t);
        }

        public static 
        void glTexCoord2dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2dv((Double*)v);
            }
        }

        public static 
        void glTexCoord2dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTexCoord2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTexCoord2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2f(Single s, Single t)
        {
            Delegates.glTexCoord2f((Single)s, (Single)t);
        }

        public static 
        void glTexCoord2fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2fv((Single*)v);
            }
        }

        public static 
        void glTexCoord2fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2i(Int32 s, Int32 t)
        {
            Delegates.glTexCoord2i((Int32)s, (Int32)t);
        }

        public static 
        void glTexCoord2iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2iv((Int32*)v);
            }
        }

        public static 
        void glTexCoord2iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTexCoord2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTexCoord2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2s(Int16 s, Int16 t)
        {
            Delegates.glTexCoord2s((Int16)s, (Int16)t);
        }

        public static 
        void glTexCoord2sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2sv((Int16*)v);
            }
        }

        public static 
        void glTexCoord2sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3d(Double s, Double t, Double r)
        {
            Delegates.glTexCoord3d((Double)s, (Double)t, (Double)r);
        }

        public static 
        void glTexCoord3dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord3dv((Double*)v);
            }
        }

        public static 
        void glTexCoord3dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTexCoord3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTexCoord3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3f(Single s, Single t, Single r)
        {
            Delegates.glTexCoord3f((Single)s, (Single)t, (Single)r);
        }

        public static 
        void glTexCoord3fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord3fv((Single*)v);
            }
        }

        public static 
        void glTexCoord3fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3i(Int32 s, Int32 t, Int32 r)
        {
            Delegates.glTexCoord3i((Int32)s, (Int32)t, (Int32)r);
        }

        public static 
        void glTexCoord3iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord3iv((Int32*)v);
            }
        }

        public static 
        void glTexCoord3iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTexCoord3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTexCoord3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3s(Int16 s, Int16 t, Int16 r)
        {
            Delegates.glTexCoord3s((Int16)s, (Int16)t, (Int16)r);
        }

        public static 
        void glTexCoord3sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord3sv((Int16*)v);
            }
        }

        public static 
        void glTexCoord3sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4d(Double s, Double t, Double r, Double q)
        {
            Delegates.glTexCoord4d((Double)s, (Double)t, (Double)r, (Double)q);
        }

        public static 
        void glTexCoord4dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord4dv((Double*)v);
            }
        }

        public static 
        void glTexCoord4dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTexCoord4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTexCoord4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4f(Single s, Single t, Single r, Single q)
        {
            Delegates.glTexCoord4f((Single)s, (Single)t, (Single)r, (Single)q);
        }

        public static 
        void glTexCoord4fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord4fv((Single*)v);
            }
        }

        public static 
        void glTexCoord4fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4i(Int32 s, Int32 t, Int32 r, Int32 q)
        {
            Delegates.glTexCoord4i((Int32)s, (Int32)t, (Int32)r, (Int32)q);
        }

        public static 
        void glTexCoord4iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord4iv((Int32*)v);
            }
        }

        public static 
        void glTexCoord4iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTexCoord4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTexCoord4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4s(Int16 s, Int16 t, Int16 r, Int16 q)
        {
            Delegates.glTexCoord4s((Int16)s, (Int16)t, (Int16)r, (Int16)q);
        }

        public static 
        void glTexCoord4sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord4sv((Int16*)v);
            }
        }

        public static 
        void glTexCoord4sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2d(Double x, Double y)
        {
            Delegates.glVertex2d((Double)x, (Double)y);
        }

        public static 
        void glVertex2dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex2dv((Double*)v);
            }
        }

        public static 
        void glVertex2dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertex2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertex2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2f(Single x, Single y)
        {
            Delegates.glVertex2f((Single)x, (Single)y);
        }

        public static 
        void glVertex2fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex2fv((Single*)v);
            }
        }

        public static 
        void glVertex2fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertex2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertex2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2i(Int32 x, Int32 y)
        {
            Delegates.glVertex2i((Int32)x, (Int32)y);
        }

        public static 
        void glVertex2iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex2iv((Int32*)v);
            }
        }

        public static 
        void glVertex2iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertex2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertex2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2s(Int16 x, Int16 y)
        {
            Delegates.glVertex2s((Int16)x, (Int16)y);
        }

        public static 
        void glVertex2sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex2sv((Int16*)v);
            }
        }

        public static 
        void glVertex2sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3d(Double x, Double y, Double z)
        {
            Delegates.glVertex3d((Double)x, (Double)y, (Double)z);
        }

        public static 
        void glVertex3dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex3dv((Double*)v);
            }
        }

        public static 
        void glVertex3dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertex3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertex3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3f(Single x, Single y, Single z)
        {
            Delegates.glVertex3f((Single)x, (Single)y, (Single)z);
        }

        public static 
        void glVertex3fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex3fv((Single*)v);
            }
        }

        public static 
        void glVertex3fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertex3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertex3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3i(Int32 x, Int32 y, Int32 z)
        {
            Delegates.glVertex3i((Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void glVertex3iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex3iv((Int32*)v);
            }
        }

        public static 
        void glVertex3iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertex3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertex3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3s(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertex3s((Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glVertex3sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex3sv((Int16*)v);
            }
        }

        public static 
        void glVertex3sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4d(Double x, Double y, Double z, Double w)
        {
            Delegates.glVertex4d((Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glVertex4dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex4dv((Double*)v);
            }
        }

        public static 
        void glVertex4dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertex4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertex4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4f(Single x, Single y, Single z, Single w)
        {
            Delegates.glVertex4f((Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glVertex4fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex4fv((Single*)v);
            }
        }

        public static 
        void glVertex4fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertex4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertex4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4i(Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glVertex4i((Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void glVertex4iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex4iv((Int32*)v);
            }
        }

        public static 
        void glVertex4iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertex4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertex4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4s(Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertex4s((Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void glVertex4sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex4sv((Int16*)v);
            }
        }

        public static 
        void glVertex4sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glClipPlane(int plane, IntPtr equation)
        {
            unsafe
            {
                Delegates.glClipPlane((int)plane, (Double*)equation);
            }
        }

        public static 
        void glClipPlane(int plane, Double[] equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = equation)
                {
                    Delegates.glClipPlane((int)plane, (Double*)equation_ptr);
                }
            }
        }

        public static 
        void glClipPlane(int plane, ref Double equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = &equation)
                {
                    Delegates.glClipPlane((int)plane, (Double*)equation_ptr);
                }
            }
        }

        public static 
        void glColorMaterial(int face, int mode)
        {
            Delegates.glColorMaterial((int)face, (int)mode);
        }

        public static 
        void glCullFace(int mode)
        {
            Delegates.glCullFace((int)mode);
        }

        public static 
        void glFogf(int pname, Single param)
        {
            Delegates.glFogf((int)pname, (Single)param);
        }

        public static 
        void glFogfv(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glFogfv((int)pname, (Single*)@params);
            }
        }

        public static 
        void glFogfv(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glFogfv((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFogfv(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glFogfv((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFogi(int pname, Int32 param)
        {
            Delegates.glFogi((int)pname, (Int32)param);
        }

        public static 
        void glFogiv(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glFogiv((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glFogiv(int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glFogiv((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFogiv(int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glFogiv((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFrontFace(int mode)
        {
            Delegates.glFrontFace((int)mode);
        }

        public static 
        void glHint(int target, int mode)
        {
            Delegates.glHint((int)target, (int)mode);
        }

        public static 
        void glLightf(int light, int pname, Single param)
        {
            Delegates.glLightf((int)light, (int)pname, (Single)param);
        }

        public static 
        void glLightfv(int light, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glLightfv((int)light, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glLightfv(int light, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glLightfv((int)light, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glLightfv(int light, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glLightfv((int)light, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glLighti(int light, int pname, Int32 param)
        {
            Delegates.glLighti((int)light, (int)pname, (Int32)param);
        }

        public static 
        void glLightiv(int light, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glLightiv((int)light, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glLightiv(int light, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glLightiv((int)light, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glLightiv(int light, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glLightiv((int)light, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glLightModelf(int pname, Single param)
        {
            Delegates.glLightModelf((int)pname, (Single)param);
        }

        public static 
        void glLightModelfv(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glLightModelfv((int)pname, (Single*)@params);
            }
        }

        public static 
        void glLightModelfv(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glLightModelfv((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glLightModelfv(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glLightModelfv((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glLightModeli(int pname, Int32 param)
        {
            Delegates.glLightModeli((int)pname, (Int32)param);
        }

        public static 
        void glLightModeliv(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glLightModeliv((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glLightModeliv(int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glLightModeliv((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glLightModeliv(int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glLightModeliv((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glLineStipple(Int32 factor, UInt16 pattern)
        {
            unsafe
            {
                Delegates.glLineStipple((Int32)factor, (UInt16)pattern);
            }
        }

        public static 
        void glLineStipple(Int32 factor, Int16 pattern)
        {
            unsafe
            {
                Delegates.glLineStipple((Int32)factor, (UInt16)pattern);
            }
        }

        public static 
        void glLineWidth(Single width)
        {
            Delegates.glLineWidth((Single)width);
        }

        public static 
        void glMaterialf(int face, int pname, Single param)
        {
            Delegates.glMaterialf((int)face, (int)pname, (Single)param);
        }

        public static 
        void glMaterialfv(int face, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glMaterialfv((int)face, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glMaterialfv(int face, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glMaterialfv((int)face, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glMaterialfv(int face, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glMaterialfv((int)face, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glMateriali(int face, int pname, Int32 param)
        {
            Delegates.glMateriali((int)face, (int)pname, (Int32)param);
        }

        public static 
        void glMaterialiv(int face, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glMaterialiv((int)face, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glMaterialiv(int face, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glMaterialiv((int)face, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glMaterialiv(int face, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glMaterialiv((int)face, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glPointSize(Single size)
        {
            Delegates.glPointSize((Single)size);
        }

        public static 
        void glPolygonMode(int face, int mode)
        {
            Delegates.glPolygonMode((int)face, (int)mode);
        }

        public static 
        void glPolygonStipple(IntPtr mask)
        {
            unsafe
            {
                Delegates.glPolygonStipple((Byte*)mask);
            }
        }

        public static 
        void glPolygonStipple(Byte[] mask)
        {
            unsafe
            {
                fixed (Byte* mask_ptr = mask)
                {
                    Delegates.glPolygonStipple((Byte*)mask_ptr);
                }
            }
        }

        public static 
        void glPolygonStipple(ref Byte mask)
        {
            unsafe
            {
                fixed (Byte* mask_ptr = &mask)
                {
                    Delegates.glPolygonStipple((Byte*)mask_ptr);
                }
            }
        }

        public static 
        void glScissor(Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glScissor((Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void glShadeModel(int mode)
        {
            Delegates.glShadeModel((int)mode);
        }

        public static 
        void glTexParameterf(int target, int pname, Single param)
        {
            Delegates.glTexParameterf((int)target, (int)pname, (Single)param);
        }

        public static 
        void glTexParameterfv(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexParameterfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glTexParameterfv(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glTexParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glTexParameterfv(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glTexParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glTexParameteri(int target, int pname, Int32 param)
        {
            Delegates.glTexParameteri((int)target, (int)pname, (Int32)param);
        }

        public static 
        void glTexParameteriv(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glTexParameteriv(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glTexParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexParameteriv(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glTexParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexImage1D(int target, Int32 level, int internalformat, Int32 width, Int32 border, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexImage1D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)border, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexImage1D(int target, Int32 level, int internalformat, Int32 width, Int32 border, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexImage1D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)border, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glTexImage2D(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 border, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexImage2D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)border, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexImage2D(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 border, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexImage2D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)border, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glTexEnvf(int target, int pname, Single param)
        {
            Delegates.glTexEnvf((int)target, (int)pname, (Single)param);
        }

        public static 
        void glTexEnvfv(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexEnvfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glTexEnvfv(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glTexEnvfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glTexEnvfv(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glTexEnvfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glTexEnvi(int target, int pname, Int32 param)
        {
            Delegates.glTexEnvi((int)target, (int)pname, (Int32)param);
        }

        public static 
        void glTexEnviv(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexEnviv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glTexEnviv(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glTexEnviv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexEnviv(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glTexEnviv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexGend(int coord, int pname, Double param)
        {
            Delegates.glTexGend((int)coord, (int)pname, (Double)param);
        }

        public static 
        void glTexGendv(int coord, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexGendv((int)coord, (int)pname, (Double*)@params);
            }
        }

        public static 
        void glTexGendv(int coord, int pname, Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glTexGendv((int)coord, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glTexGendv(int coord, int pname, ref Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glTexGendv((int)coord, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glTexGenf(int coord, int pname, Single param)
        {
            Delegates.glTexGenf((int)coord, (int)pname, (Single)param);
        }

        public static 
        void glTexGenfv(int coord, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexGenfv((int)coord, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glTexGenfv(int coord, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glTexGenfv((int)coord, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glTexGenfv(int coord, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glTexGenfv((int)coord, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glTexGeni(int coord, int pname, Int32 param)
        {
            Delegates.glTexGeni((int)coord, (int)pname, (Int32)param);
        }

        public static 
        void glTexGeniv(int coord, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexGeniv((int)coord, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glTexGeniv(int coord, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glTexGeniv((int)coord, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexGeniv(int coord, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glTexGeniv((int)coord, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFeedbackBuffer(Int32 size, int type, [Out] IntPtr buffer)
        {
            unsafe
            {
                Delegates.glFeedbackBuffer((Int32)size, (int)type, (Single*)buffer);
            }
        }

        public static 
        void glFeedbackBuffer(Int32 size, int type, [Out] Single[] buffer)
        {
            unsafe
            {
                fixed (Single* buffer_ptr = buffer)
                {
                    Delegates.glFeedbackBuffer((Int32)size, (int)type, (Single*)buffer_ptr);
                }
            }
        }

        public static 
        void glFeedbackBuffer(Int32 size, int type, [Out] out Single buffer)
        {
            unsafe
            {
                fixed (Single* buffer_ptr = &buffer)
                {
                    Delegates.glFeedbackBuffer((Int32)size, (int)type, (Single*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }

        public static 
        void glSelectBuffer(Int32 size, [Out] IntPtr buffer)
        {
            unsafe
            {
                Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSelectBuffer(Int32 size, [Out] UInt32[] buffer)
        {
            unsafe
            {
                fixed (UInt32* buffer_ptr = buffer)
                {
                    Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
                }
            }
        }

        public static 
        void glSelectBuffer(Int32 size, [Out] Int32[] buffer)
        {
            unsafe
            {
                fixed (Int32* buffer_ptr = buffer)
                {
                    Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSelectBuffer(Int32 size, [Out] out UInt32 buffer)
        {
            unsafe
            {
                fixed (UInt32* buffer_ptr = &buffer)
                {
                    Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }

        public static 
        void glSelectBuffer(Int32 size, [Out] out Int32 buffer)
        {
            unsafe
            {
                fixed (Int32* buffer_ptr = &buffer)
                {
                    Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }

        public static 
        Int32 glRenderMode(int mode)
        {
            return Delegates.glRenderMode((int)mode);
        }

        public static 
        void glInitNames()
        {
            Delegates.glInitNames();
        }

        [System.CLSCompliant(false)]
        public static 
        void glLoadName(UInt32 name)
        {
            Delegates.glLoadName((UInt32)name);
        }

        public static 
        void glLoadName(Int32 name)
        {
            Delegates.glLoadName((UInt32)name);
        }

        public static 
        void glPassThrough(Single token)
        {
            Delegates.glPassThrough((Single)token);
        }

        public static 
        void glPopName()
        {
            Delegates.glPopName();
        }

        [System.CLSCompliant(false)]
        public static 
        void glPushName(UInt32 name)
        {
            Delegates.glPushName((UInt32)name);
        }

        public static 
        void glPushName(Int32 name)
        {
            Delegates.glPushName((UInt32)name);
        }

        public static 
        void glDrawBuffer(int mode)
        {
            Delegates.glDrawBuffer((int)mode);
        }

        public static 
        void glClear(int mask)
        {
            Delegates.glClear((int)mask);
        }

        public static 
        void glClearAccum(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glClearAccum((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void glClearIndex(Single c)
        {
            Delegates.glClearIndex((Single)c);
        }

        public static 
        void glClearColor(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glClearColor((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void glClearStencil(Int32 s)
        {
            Delegates.glClearStencil((Int32)s);
        }

        public static 
        void glClearDepth(Double depth)
        {
            Delegates.glClearDepth((Double)depth);
        }

        [System.CLSCompliant(false)]
        public static 
        void glStencilMask(UInt32 mask)
        {
            Delegates.glStencilMask((UInt32)mask);
        }

        public static 
        void glStencilMask(Int32 mask)
        {
            Delegates.glStencilMask((UInt32)mask);
        }

        public static 
        void glColorMask(Int32 red, Int32 green, Int32 blue, Int32 alpha)
        {
            Delegates.glColorMask((Int32)red, (Int32)green, (Int32)blue, (Int32)alpha);
        }

        public static 
        void glDepthMask(Int32 flag)
        {
            Delegates.glDepthMask((Int32)flag);
        }

        [System.CLSCompliant(false)]
        public static 
        void glIndexMask(UInt32 mask)
        {
            Delegates.glIndexMask((UInt32)mask);
        }

        public static 
        void glIndexMask(Int32 mask)
        {
            Delegates.glIndexMask((UInt32)mask);
        }

        public static 
        void glAccum(int op, Single value)
        {
            Delegates.glAccum((int)op, (Single)value);
        }

        public static 
        void glDisable(int cap)
        {
            Delegates.glDisable((int)cap);
        }

        public static 
        void glEnable(int cap)
        {
            Delegates.glEnable((int)cap);
        }

        public static 
        void glFinish()
        {
            Delegates.glFinish();
        }

        public static 
        void glFlush()
        {
            Delegates.glFlush();
        }

        public static 
        void glPopAttrib()
        {
            Delegates.glPopAttrib();
        }

        public static 
        void glPushAttrib(int mask)
        {
            Delegates.glPushAttrib((int)mask);
        }

        public static 
        void glMap1d(int target, Double u1, Double u2, Int32 stride, Int32 order, IntPtr points)
        {
            unsafe
            {
                Delegates.glMap1d((int)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points);
            }
        }

        public static 
        void glMap1d(int target, Double u1, Double u2, Int32 stride, Int32 order, Double[] points)
        {
            unsafe
            {
                fixed (Double* points_ptr = points)
                {
                    Delegates.glMap1d((int)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points_ptr);
                }
            }
        }

        public static 
        void glMap1d(int target, Double u1, Double u2, Int32 stride, Int32 order, ref Double points)
        {
            unsafe
            {
                fixed (Double* points_ptr = &points)
                {
                    Delegates.glMap1d((int)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points_ptr);
                }
            }
        }

        public static 
        void glMap1f(int target, Single u1, Single u2, Int32 stride, Int32 order, IntPtr points)
        {
            unsafe
            {
                Delegates.glMap1f((int)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points);
            }
        }

        public static 
        void glMap1f(int target, Single u1, Single u2, Int32 stride, Int32 order, Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glMap1f((int)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glMap1f(int target, Single u1, Single u2, Int32 stride, Int32 order, ref Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glMap1f((int)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glMap2d(int target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, IntPtr points)
        {
            unsafe
            {
                Delegates.glMap2d((int)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points);
            }
        }

        public static 
        void glMap2d(int target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double[] points)
        {
            unsafe
            {
                fixed (Double* points_ptr = points)
                {
                    Delegates.glMap2d((int)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points_ptr);
                }
            }
        }

        public static 
        void glMap2d(int target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, ref Double points)
        {
            unsafe
            {
                fixed (Double* points_ptr = &points)
                {
                    Delegates.glMap2d((int)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points_ptr);
                }
            }
        }

        public static 
        void glMap2f(int target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, IntPtr points)
        {
            unsafe
            {
                Delegates.glMap2f((int)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points);
            }
        }

        public static 
        void glMap2f(int target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glMap2f((int)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glMap2f(int target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, ref Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glMap2f((int)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glMapGrid1d(Int32 un, Double u1, Double u2)
        {
            Delegates.glMapGrid1d((Int32)un, (Double)u1, (Double)u2);
        }

        public static 
        void glMapGrid1f(Int32 un, Single u1, Single u2)
        {
            Delegates.glMapGrid1f((Int32)un, (Single)u1, (Single)u2);
        }

        public static 
        void glMapGrid2d(Int32 un, Double u1, Double u2, Int32 vn, Double v1, Double v2)
        {
            Delegates.glMapGrid2d((Int32)un, (Double)u1, (Double)u2, (Int32)vn, (Double)v1, (Double)v2);
        }

        public static 
        void glMapGrid2f(Int32 un, Single u1, Single u2, Int32 vn, Single v1, Single v2)
        {
            Delegates.glMapGrid2f((Int32)un, (Single)u1, (Single)u2, (Int32)vn, (Single)v1, (Single)v2);
        }

        public static 
        void glEvalCoord1d(Double u)
        {
            Delegates.glEvalCoord1d((Double)u);
        }

        public static 
        void glEvalCoord1dv(IntPtr u)
        {
            unsafe
            {
                Delegates.glEvalCoord1dv((Double*)u);
            }
        }

        public static 
        void glEvalCoord1dv(Double[] u)
        {
            unsafe
            {
                fixed (Double* u_ptr = u)
                {
                    Delegates.glEvalCoord1dv((Double*)u_ptr);
                }
            }
        }

        public static 
        void glEvalCoord1dv(ref Double u)
        {
            unsafe
            {
                fixed (Double* u_ptr = &u)
                {
                    Delegates.glEvalCoord1dv((Double*)u_ptr);
                }
            }
        }

        public static 
        void glEvalCoord1f(Single u)
        {
            Delegates.glEvalCoord1f((Single)u);
        }

        public static 
        void glEvalCoord1fv(IntPtr u)
        {
            unsafe
            {
                Delegates.glEvalCoord1fv((Single*)u);
            }
        }

        public static 
        void glEvalCoord1fv(Single[] u)
        {
            unsafe
            {
                fixed (Single* u_ptr = u)
                {
                    Delegates.glEvalCoord1fv((Single*)u_ptr);
                }
            }
        }

        public static 
        void glEvalCoord1fv(ref Single u)
        {
            unsafe
            {
                fixed (Single* u_ptr = &u)
                {
                    Delegates.glEvalCoord1fv((Single*)u_ptr);
                }
            }
        }

        public static 
        void glEvalCoord2d(Double u, Double v)
        {
            Delegates.glEvalCoord2d((Double)u, (Double)v);
        }

        public static 
        void glEvalCoord2dv(IntPtr u)
        {
            unsafe
            {
                Delegates.glEvalCoord2dv((Double*)u);
            }
        }

        public static 
        void glEvalCoord2dv(Double[] u)
        {
            unsafe
            {
                fixed (Double* u_ptr = u)
                {
                    Delegates.glEvalCoord2dv((Double*)u_ptr);
                }
            }
        }

        public static 
        void glEvalCoord2dv(ref Double u)
        {
            unsafe
            {
                fixed (Double* u_ptr = &u)
                {
                    Delegates.glEvalCoord2dv((Double*)u_ptr);
                }
            }
        }

        public static 
        void glEvalCoord2f(Single u, Single v)
        {
            Delegates.glEvalCoord2f((Single)u, (Single)v);
        }

        public static 
        void glEvalCoord2fv(IntPtr u)
        {
            unsafe
            {
                Delegates.glEvalCoord2fv((Single*)u);
            }
        }

        public static 
        void glEvalCoord2fv(Single[] u)
        {
            unsafe
            {
                fixed (Single* u_ptr = u)
                {
                    Delegates.glEvalCoord2fv((Single*)u_ptr);
                }
            }
        }

        public static 
        void glEvalCoord2fv(ref Single u)
        {
            unsafe
            {
                fixed (Single* u_ptr = &u)
                {
                    Delegates.glEvalCoord2fv((Single*)u_ptr);
                }
            }
        }

        public static 
        void glEvalMesh1(int mode, Int32 i1, Int32 i2)
        {
            Delegates.glEvalMesh1((int)mode, (Int32)i1, (Int32)i2);
        }

        public static 
        void glEvalPoint1(Int32 i)
        {
            Delegates.glEvalPoint1((Int32)i);
        }

        public static 
        void glEvalMesh2(int mode, Int32 i1, Int32 i2, Int32 j1, Int32 j2)
        {
            Delegates.glEvalMesh2((int)mode, (Int32)i1, (Int32)i2, (Int32)j1, (Int32)j2);
        }

        public static 
        void glEvalPoint2(Int32 i, Int32 j)
        {
            Delegates.glEvalPoint2((Int32)i, (Int32)j);
        }

        public static 
        void glAlphaFunc(int func, Single @ref)
        {
            Delegates.glAlphaFunc((int)func, (Single)@ref);
        }

        public static 
        void glBlendFunc(int sfactor, int dfactor)
        {
            Delegates.glBlendFunc((int)sfactor, (int)dfactor);
        }

        public static 
        void glLogicOp(int opcode)
        {
            Delegates.glLogicOp((int)opcode);
        }

        [System.CLSCompliant(false)]
        public static 
        void glStencilFunc(int func, Int32 @ref, UInt32 mask)
        {
            Delegates.glStencilFunc((int)func, (Int32)@ref, (UInt32)mask);
        }

        public static 
        void glStencilFunc(int func, Int32 @ref, Int32 mask)
        {
            Delegates.glStencilFunc((int)func, (Int32)@ref, (UInt32)mask);
        }

        public static 
        void glStencilOp(int fail, int zfail, int zpass)
        {
            Delegates.glStencilOp((int)fail, (int)zfail, (int)zpass);
        }

        public static 
        void glDepthFunc(int func)
        {
            Delegates.glDepthFunc((int)func);
        }

        public static 
        void glPixelZoom(Single xfactor, Single yfactor)
        {
            Delegates.glPixelZoom((Single)xfactor, (Single)yfactor);
        }

        public static 
        void glPixelTransferf(int pname, Single param)
        {
            Delegates.glPixelTransferf((int)pname, (Single)param);
        }

        public static 
        void glPixelTransferi(int pname, Int32 param)
        {
            Delegates.glPixelTransferi((int)pname, (Int32)param);
        }

        public static 
        void glPixelStoref(int pname, Single param)
        {
            Delegates.glPixelStoref((int)pname, (Single)param);
        }

        public static 
        void glPixelStorei(int pname, Int32 param)
        {
            Delegates.glPixelStorei((int)pname, (Int32)param);
        }

        public static 
        void glPixelMapfv(int map, Int32 mapsize, IntPtr values)
        {
            unsafe
            {
                Delegates.glPixelMapfv((int)map, (Int32)mapsize, (Single*)values);
            }
        }

        public static 
        void glPixelMapfv(int map, Int32 mapsize, Single[] values)
        {
            unsafe
            {
                fixed (Single* values_ptr = values)
                {
                    Delegates.glPixelMapfv((int)map, (Int32)mapsize, (Single*)values_ptr);
                }
            }
        }

        public static 
        void glPixelMapfv(int map, Int32 mapsize, ref Single values)
        {
            unsafe
            {
                fixed (Single* values_ptr = &values)
                {
                    Delegates.glPixelMapfv((int)map, (Int32)mapsize, (Single*)values_ptr);
                }
            }
        }

        public static 
        void glPixelMapuiv(int map, Int32 mapsize, IntPtr values)
        {
            unsafe
            {
                Delegates.glPixelMapuiv((int)map, (Int32)mapsize, (UInt32*)values);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPixelMapuiv(int map, Int32 mapsize, UInt32[] values)
        {
            unsafe
            {
                fixed (UInt32* values_ptr = values)
                {
                    Delegates.glPixelMapuiv((int)map, (Int32)mapsize, (UInt32*)values_ptr);
                }
            }
        }

        public static 
        void glPixelMapuiv(int map, Int32 mapsize, Int32[] values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = values)
                {
                    Delegates.glPixelMapuiv((int)map, (Int32)mapsize, (UInt32*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPixelMapuiv(int map, Int32 mapsize, ref UInt32 values)
        {
            unsafe
            {
                fixed (UInt32* values_ptr = &values)
                {
                    Delegates.glPixelMapuiv((int)map, (Int32)mapsize, (UInt32*)values_ptr);
                }
            }
        }

        public static 
        void glPixelMapuiv(int map, Int32 mapsize, ref Int32 values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = &values)
                {
                    Delegates.glPixelMapuiv((int)map, (Int32)mapsize, (UInt32*)values_ptr);
                }
            }
        }

        public static 
        void glPixelMapusv(int map, Int32 mapsize, IntPtr values)
        {
            unsafe
            {
                Delegates.glPixelMapusv((int)map, (Int32)mapsize, (UInt16*)values);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPixelMapusv(int map, Int32 mapsize, UInt16[] values)
        {
            unsafe
            {
                fixed (UInt16* values_ptr = values)
                {
                    Delegates.glPixelMapusv((int)map, (Int32)mapsize, (UInt16*)values_ptr);
                }
            }
        }

        public static 
        void glPixelMapusv(int map, Int32 mapsize, Int16[] values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = values)
                {
                    Delegates.glPixelMapusv((int)map, (Int32)mapsize, (UInt16*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPixelMapusv(int map, Int32 mapsize, ref UInt16 values)
        {
            unsafe
            {
                fixed (UInt16* values_ptr = &values)
                {
                    Delegates.glPixelMapusv((int)map, (Int32)mapsize, (UInt16*)values_ptr);
                }
            }
        }

        public static 
        void glPixelMapusv(int map, Int32 mapsize, ref Int16 values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = &values)
                {
                    Delegates.glPixelMapusv((int)map, (Int32)mapsize, (UInt16*)values_ptr);
                }
            }
        }

        public static 
        void glReadBuffer(int mode)
        {
            Delegates.glReadBuffer((int)mode);
        }

        public static 
        void glCopyPixels(Int32 x, Int32 y, Int32 width, Int32 height, int type)
        {
            Delegates.glCopyPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (int)type);
        }

        public static 
        void glReadPixels(Int32 x, Int32 y, Int32 width, Int32 height, int format, int type, [Out] IntPtr pixels)
        {
            unsafe
            {
                Delegates.glReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glReadPixels(Int32 x, Int32 y, Int32 width, Int32 height, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glDrawPixels(Int32 width, Int32 height, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glDrawPixels((Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glDrawPixels(Int32 width, Int32 height, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawPixels((Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glGetBooleanv(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetBooleanv((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetBooleanv(int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetBooleanv((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetBooleanv(int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetBooleanv((int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetClipPlane(int plane, [Out] IntPtr equation)
        {
            unsafe
            {
                Delegates.glGetClipPlane((int)plane, (Double*)equation);
            }
        }

        public static 
        void glGetClipPlane(int plane, [Out] Double[] equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = equation)
                {
                    Delegates.glGetClipPlane((int)plane, (Double*)equation_ptr);
                }
            }
        }

        public static 
        void glGetClipPlane(int plane, [Out] out Double equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = &equation)
                {
                    Delegates.glGetClipPlane((int)plane, (Double*)equation_ptr);
                    equation = *equation_ptr;
                }
            }
        }

        public static 
        void glGetDoublev(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetDoublev((int)pname, (Double*)@params);
            }
        }

        public static 
        void glGetDoublev(int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetDoublev((int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetDoublev(int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetDoublev((int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        int glGetError()
        {
            return Delegates.glGetError();
        }

        public static 
        void glGetFloatv(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFloatv((int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetFloatv(int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetFloatv((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFloatv(int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetFloatv((int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetIntegerv(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetIntegerv((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetIntegerv(int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetIntegerv((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetIntegerv(int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetIntegerv((int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetLightfv(int light, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetLightfv((int)light, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetLightfv(int light, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetLightfv((int)light, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetLightfv(int light, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetLightfv((int)light, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetLightiv(int light, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetLightiv((int)light, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetLightiv(int light, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetLightiv((int)light, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetLightiv(int light, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetLightiv((int)light, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMapdv(int target, int query, [Out] IntPtr v)
        {
            unsafe
            {
                Delegates.glGetMapdv((int)target, (int)query, (Double*)v);
            }
        }

        public static 
        void glGetMapdv(int target, int query, [Out] Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glGetMapdv((int)target, (int)query, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glGetMapdv(int target, int query, [Out] out Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glGetMapdv((int)target, (int)query, (Double*)v_ptr);
                    v = *v_ptr;
                }
            }
        }

        public static 
        void glGetMapfv(int target, int query, [Out] IntPtr v)
        {
            unsafe
            {
                Delegates.glGetMapfv((int)target, (int)query, (Single*)v);
            }
        }

        public static 
        void glGetMapfv(int target, int query, [Out] Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glGetMapfv((int)target, (int)query, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glGetMapfv(int target, int query, [Out] out Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glGetMapfv((int)target, (int)query, (Single*)v_ptr);
                    v = *v_ptr;
                }
            }
        }

        public static 
        void glGetMapiv(int target, int query, [Out] IntPtr v)
        {
            unsafe
            {
                Delegates.glGetMapiv((int)target, (int)query, (Int32*)v);
            }
        }

        public static 
        void glGetMapiv(int target, int query, [Out] Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glGetMapiv((int)target, (int)query, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glGetMapiv(int target, int query, [Out] out Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glGetMapiv((int)target, (int)query, (Int32*)v_ptr);
                    v = *v_ptr;
                }
            }
        }

        public static 
        void glGetMaterialfv(int face, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMaterialfv((int)face, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetMaterialfv(int face, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetMaterialfv((int)face, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMaterialfv(int face, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetMaterialfv((int)face, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMaterialiv(int face, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMaterialiv((int)face, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetMaterialiv(int face, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetMaterialiv((int)face, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMaterialiv(int face, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetMaterialiv((int)face, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetPixelMapfv(int map, [Out] IntPtr values)
        {
            unsafe
            {
                Delegates.glGetPixelMapfv((int)map, (Single*)values);
            }
        }

        public static 
        void glGetPixelMapfv(int map, [Out] Single[] values)
        {
            unsafe
            {
                fixed (Single* values_ptr = values)
                {
                    Delegates.glGetPixelMapfv((int)map, (Single*)values_ptr);
                }
            }
        }

        public static 
        void glGetPixelMapfv(int map, [Out] out Single values)
        {
            unsafe
            {
                fixed (Single* values_ptr = &values)
                {
                    Delegates.glGetPixelMapfv((int)map, (Single*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        public static 
        void glGetPixelMapuiv(int map, [Out] IntPtr values)
        {
            unsafe
            {
                Delegates.glGetPixelMapuiv((int)map, (UInt32*)values);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetPixelMapuiv(int map, [Out] UInt32[] values)
        {
            unsafe
            {
                fixed (UInt32* values_ptr = values)
                {
                    Delegates.glGetPixelMapuiv((int)map, (UInt32*)values_ptr);
                }
            }
        }

        public static 
        void glGetPixelMapuiv(int map, [Out] Int32[] values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = values)
                {
                    Delegates.glGetPixelMapuiv((int)map, (UInt32*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetPixelMapuiv(int map, [Out] out UInt32 values)
        {
            unsafe
            {
                fixed (UInt32* values_ptr = &values)
                {
                    Delegates.glGetPixelMapuiv((int)map, (UInt32*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        public static 
        void glGetPixelMapuiv(int map, [Out] out Int32 values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = &values)
                {
                    Delegates.glGetPixelMapuiv((int)map, (UInt32*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        public static 
        void glGetPixelMapusv(int map, [Out] IntPtr values)
        {
            unsafe
            {
                Delegates.glGetPixelMapusv((int)map, (UInt16*)values);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetPixelMapusv(int map, [Out] UInt16[] values)
        {
            unsafe
            {
                fixed (UInt16* values_ptr = values)
                {
                    Delegates.glGetPixelMapusv((int)map, (UInt16*)values_ptr);
                }
            }
        }

        public static 
        void glGetPixelMapusv(int map, [Out] Int16[] values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = values)
                {
                    Delegates.glGetPixelMapusv((int)map, (UInt16*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetPixelMapusv(int map, [Out] out UInt16 values)
        {
            unsafe
            {
                fixed (UInt16* values_ptr = &values)
                {
                    Delegates.glGetPixelMapusv((int)map, (UInt16*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        public static 
        void glGetPixelMapusv(int map, [Out] out Int16 values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = &values)
                {
                    Delegates.glGetPixelMapusv((int)map, (UInt16*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        public static 
        void glGetPolygonStipple([Out] IntPtr mask)
        {
            unsafe
            {
                Delegates.glGetPolygonStipple((Byte*)mask);
            }
        }

        public static 
        void glGetPolygonStipple([Out] Byte[] mask)
        {
            unsafe
            {
                fixed (Byte* mask_ptr = mask)
                {
                    Delegates.glGetPolygonStipple((Byte*)mask_ptr);
                }
            }
        }

        public static 
        void glGetPolygonStipple([Out] out Byte mask)
        {
            unsafe
            {
                fixed (Byte* mask_ptr = &mask)
                {
                    Delegates.glGetPolygonStipple((Byte*)mask_ptr);
                    mask = *mask_ptr;
                }
            }
        }

        public static 
        string glGetString(int name)
        {
            unsafe
            {
                return System.Runtime.InteropServices.Marshal.PtrToStringAnsi(Delegates.glGetString((int)name));
            }
        }

        public static 
        void glGetTexEnvfv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexEnvfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetTexEnvfv(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetTexEnvfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexEnvfv(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetTexEnvfv((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexEnviv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexEnviv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetTexEnviv(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexEnviv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexEnviv(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexEnviv((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexGendv(int coord, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexGendv((int)coord, (int)pname, (Double*)@params);
            }
        }

        public static 
        void glGetTexGendv(int coord, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetTexGendv((int)coord, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexGendv(int coord, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetTexGendv((int)coord, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexGenfv(int coord, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexGenfv((int)coord, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetTexGenfv(int coord, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetTexGenfv((int)coord, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexGenfv(int coord, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetTexGenfv((int)coord, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexGeniv(int coord, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexGeniv((int)coord, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetTexGeniv(int coord, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexGeniv((int)coord, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexGeniv(int coord, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexGeniv((int)coord, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexImage(int target, Int32 level, int format, int type, [Out] IntPtr pixels)
        {
            unsafe
            {
                Delegates.glGetTexImage((int)target, (Int32)level, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glGetTexImage(int target, Int32 level, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetTexImage((int)target, (Int32)level, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glGetTexParameterfv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexParameterfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetTexParameterfv(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetTexParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexParameterfv(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexParameteriv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetTexParameteriv(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexParameteriv(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexLevelParameterfv(int target, Int32 level, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexLevelParameterfv((int)target, (Int32)level, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetTexLevelParameterfv(int target, Int32 level, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetTexLevelParameterfv((int)target, (Int32)level, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexLevelParameterfv(int target, Int32 level, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetTexLevelParameterfv((int)target, (Int32)level, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexLevelParameteriv(int target, Int32 level, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexLevelParameteriv((int)target, (Int32)level, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetTexLevelParameteriv(int target, Int32 level, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexLevelParameteriv((int)target, (Int32)level, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexLevelParameteriv(int target, Int32 level, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexLevelParameteriv((int)target, (Int32)level, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        Int32 glIsEnabled(int cap)
        {
            return Delegates.glIsEnabled((int)cap);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsList(UInt32 list)
        {
            return Delegates.glIsList((UInt32)list);
        }

        public static 
        Int32 glIsList(Int32 list)
        {
            return Delegates.glIsList((UInt32)list);
        }

        public static 
        void glDepthRange(Double near, Double far)
        {
            Delegates.glDepthRange((Double)near, (Double)far);
        }

        public static 
        void glFrustum(Double left, Double right, Double bottom, Double top, Double zNear, Double zFar)
        {
            Delegates.glFrustum((Double)left, (Double)right, (Double)bottom, (Double)top, (Double)zNear, (Double)zFar);
        }

        public static 
        void glLoadIdentity()
        {
            Delegates.glLoadIdentity();
        }

        public static 
        void glLoadMatrixf(IntPtr m)
        {
            unsafe
            {
                Delegates.glLoadMatrixf((Single*)m);
            }
        }

        public static 
        void glLoadMatrixf(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glLoadMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void glLoadMatrixf(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glLoadMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void glLoadMatrixd(IntPtr m)
        {
            unsafe
            {
                Delegates.glLoadMatrixd((Double*)m);
            }
        }

        public static 
        void glLoadMatrixd(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glLoadMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void glLoadMatrixd(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glLoadMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void glMatrixMode(int mode)
        {
            Delegates.glMatrixMode((int)mode);
        }

        public static 
        void glMultMatrixf(IntPtr m)
        {
            unsafe
            {
                Delegates.glMultMatrixf((Single*)m);
            }
        }

        public static 
        void glMultMatrixf(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glMultMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void glMultMatrixf(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glMultMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void glMultMatrixd(IntPtr m)
        {
            unsafe
            {
                Delegates.glMultMatrixd((Double*)m);
            }
        }

        public static 
        void glMultMatrixd(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glMultMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void glMultMatrixd(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glMultMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void glOrtho(Double left, Double right, Double bottom, Double top, Double zNear, Double zFar)
        {
            Delegates.glOrtho((Double)left, (Double)right, (Double)bottom, (Double)top, (Double)zNear, (Double)zFar);
        }

        public static 
        void glPopMatrix()
        {
            Delegates.glPopMatrix();
        }

        public static 
        void glPushMatrix()
        {
            Delegates.glPushMatrix();
        }

        public static 
        void glRotated(Double angle, Double x, Double y, Double z)
        {
            Delegates.glRotated((Double)angle, (Double)x, (Double)y, (Double)z);
        }

        public static 
        void glRotatef(Single angle, Single x, Single y, Single z)
        {
            Delegates.glRotatef((Single)angle, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glScaled(Double x, Double y, Double z)
        {
            Delegates.glScaled((Double)x, (Double)y, (Double)z);
        }

        public static 
        void glScalef(Single x, Single y, Single z)
        {
            Delegates.glScalef((Single)x, (Single)y, (Single)z);
        }

        public static 
        void glTranslated(Double x, Double y, Double z)
        {
            Delegates.glTranslated((Double)x, (Double)y, (Double)z);
        }

        public static 
        void glTranslatef(Single x, Single y, Single z)
        {
            Delegates.glTranslatef((Single)x, (Single)y, (Single)z);
        }

        public static 
        void glViewport(Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glViewport((Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void glArrayElement(Int32 i)
        {
            Delegates.glArrayElement((Int32)i);
        }

        public static 
        void glColorPointer(Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glColorPointer((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glColorPointer(Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorPointer((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glDisableClientState(int array)
        {
            Delegates.glDisableClientState((int)array);
        }

        public static 
        void glDrawArrays(int mode, Int32 first, Int32 count)
        {
            Delegates.glDrawArrays((int)mode, (Int32)first, (Int32)count);
        }

        public static 
        void glDrawElements(int mode, Int32 count, int type, IntPtr indices)
        {
            unsafe
            {
                Delegates.glDrawElements((int)mode, (Int32)count, (int)type, (IntPtr)indices);
            }
        }

        public static 
        void glDrawElements(int mode, Int32 count, int type, [In, Out] object indices)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawElements((int)mode, (Int32)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        public static 
        void glEdgeFlagPointer(Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glEdgeFlagPointer((Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glEdgeFlagPointer(Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glEdgeFlagPointer((Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glEnableClientState(int array)
        {
            Delegates.glEnableClientState((int)array);
        }

        public static 
        void glGetPointerv(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetPointerv((int)pname, (IntPtr)@params);
            }
        }

        public static 
        void glGetPointerv(int pname, [In, Out] object @params)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetPointerv((int)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }
        }

        public static 
        void glIndexPointer(int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glIndexPointer((int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glIndexPointer(int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glIndexPointer((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glInterleavedArrays(int format, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glInterleavedArrays((int)format, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glInterleavedArrays(int format, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glInterleavedArrays((int)format, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glNormalPointer(int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glNormalPointer((int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glNormalPointer(int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glNormalPointer((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glTexCoordPointer(Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glTexCoordPointer((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glTexCoordPointer(Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexCoordPointer((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexPointer(Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexPointer((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexPointer(Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexPointer((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glPolygonOffset(Single factor, Single units)
        {
            Delegates.glPolygonOffset((Single)factor, (Single)units);
        }

        public static 
        void glCopyTexImage1D(int target, Int32 level, int internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
        {
            Delegates.glCopyTexImage1D((int)target, (Int32)level, (int)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)border);
        }

        public static 
        void glCopyTexImage2D(int target, Int32 level, int internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
        {
            Delegates.glCopyTexImage2D((int)target, (Int32)level, (int)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height, (Int32)border);
        }

        public static 
        void glCopyTexSubImage1D(int target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyTexSubImage1D((int)target, (Int32)level, (Int32)xoffset, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void glCopyTexSubImage2D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyTexSubImage2D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void glTexSubImage1D(int target, Int32 level, Int32 xoffset, Int32 width, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexSubImage1D((int)target, (Int32)level, (Int32)xoffset, (Int32)width, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexSubImage1D(int target, Int32 level, Int32 xoffset, Int32 width, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage1D((int)target, (Int32)level, (Int32)xoffset, (Int32)width, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glTexSubImage2D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexSubImage2D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexSubImage2D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage2D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, IntPtr textures, [Out] IntPtr residences)
        {
            unsafe
            {
                return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures, (Int32*)residences);
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, IntPtr textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, IntPtr textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResident(Int32 n, UInt32[] textures, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences);
                }
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, Int32[] textures, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResident(Int32 n, UInt32[] textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, Int32[] textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResident(Int32 n, UInt32[] textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, Int32[] textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResident(Int32 n, ref UInt32 textures, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences);
                }
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, ref Int32 textures, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResident(Int32 n, ref UInt32 textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, ref Int32 textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResident(Int32 n, ref UInt32 textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glAreTexturesResident(Int32 n, ref Int32 textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindTexture(int target, UInt32 texture)
        {
            Delegates.glBindTexture((int)target, (UInt32)texture);
        }

        public static 
        void glBindTexture(int target, Int32 texture)
        {
            Delegates.glBindTexture((int)target, (UInt32)texture);
        }

        public static 
        void glDeleteTextures(Int32 n, IntPtr textures)
        {
            unsafe
            {
                Delegates.glDeleteTextures((Int32)n, (UInt32*)textures);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteTextures(Int32 n, UInt32[] textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void glDeleteTextures(Int32 n, Int32[] textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteTextures(Int32 n, ref UInt32 textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void glDeleteTextures(Int32 n, ref Int32 textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void glGenTextures(Int32 n, [Out] IntPtr textures)
        {
            unsafe
            {
                Delegates.glGenTextures((Int32)n, (UInt32*)textures);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenTextures(Int32 n, [Out] UInt32[] textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void glGenTextures(Int32 n, [Out] Int32[] textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenTextures(Int32 n, [Out] out UInt32 textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
                    textures = *textures_ptr;
                }
            }
        }

        public static 
        void glGenTextures(Int32 n, [Out] out Int32 textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
                    textures = *textures_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsTexture(UInt32 texture)
        {
            return Delegates.glIsTexture((UInt32)texture);
        }

        public static 
        Int32 glIsTexture(Int32 texture)
        {
            return Delegates.glIsTexture((UInt32)texture);
        }

        public static 
        void glPrioritizeTextures(Int32 n, IntPtr textures, IntPtr priorities)
        {
            unsafe
            {
                Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities);
            }
        }

        public static 
        void glPrioritizeTextures(Int32 n, IntPtr textures, Single[] priorities)
        {
            unsafe
            {
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTextures(Int32 n, IntPtr textures, ref Single priorities)
        {
            unsafe
            {
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTextures(Int32 n, UInt32[] textures, IntPtr priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
                }
            }
        }

        public static 
        void glPrioritizeTextures(Int32 n, Int32[] textures, IntPtr priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTextures(Int32 n, UInt32[] textures, Single[] priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTextures(Int32 n, Int32[] textures, Single[] priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTextures(Int32 n, UInt32[] textures, ref Single priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTextures(Int32 n, Int32[] textures, ref Single priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTextures(Int32 n, ref UInt32 textures, IntPtr priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
                }
            }
        }

        public static 
        void glPrioritizeTextures(Int32 n, ref Int32 textures, IntPtr priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTextures(Int32 n, ref UInt32 textures, Single[] priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTextures(Int32 n, ref Int32 textures, Single[] priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTextures(Int32 n, ref UInt32 textures, ref Single priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTextures(Int32 n, ref Int32 textures, ref Single priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glIndexub(Byte c)
        {
            Delegates.glIndexub((Byte)c);
        }

        public static 
        void glIndexubv(IntPtr c)
        {
            unsafe
            {
                Delegates.glIndexubv((Byte*)c);
            }
        }

        public static 
        void glIndexubv(Byte[] c)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glIndexubv((Byte*)c_ptr);
                }
            }
        }

        public static 
        void glIndexubv(ref Byte c)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glIndexubv((Byte*)c_ptr);
                }
            }
        }

        public static 
        void glPopClientAttrib()
        {
            Delegates.glPopClientAttrib();
        }

        public static 
        void glPushClientAttrib(int mask)
        {
            Delegates.glPushClientAttrib((int)mask);
        }

        public static 
        void glBlendColor(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glBlendColor((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void glBlendEquation(int mode)
        {
            Delegates.glBlendEquation((int)mode);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDrawRangeElements(int mode, UInt32 start, UInt32 end, Int32 count, int type, IntPtr indices)
        {
            unsafe
            {
                Delegates.glDrawRangeElements((int)mode, (UInt32)start, (UInt32)end, (Int32)count, (int)type, (IntPtr)indices);
            }
        }

        public static 
        void glDrawRangeElements(int mode, Int32 start, Int32 end, Int32 count, int type, IntPtr indices)
        {
            unsafe
            {
                Delegates.glDrawRangeElements((int)mode, (UInt32)start, (UInt32)end, (Int32)count, (int)type, (IntPtr)indices);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDrawRangeElements(int mode, UInt32 start, UInt32 end, Int32 count, int type, [In, Out] object indices)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawRangeElements((int)mode, (UInt32)start, (UInt32)end, (Int32)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        public static 
        void glDrawRangeElements(int mode, Int32 start, Int32 end, Int32 count, int type, [In, Out] object indices)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawRangeElements((int)mode, (UInt32)start, (UInt32)end, (Int32)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        public static 
        void glColorTable(int target, int internalformat, Int32 width, int format, int type, IntPtr table)
        {
            unsafe
            {
                Delegates.glColorTable((int)target, (int)internalformat, (Int32)width, (int)format, (int)type, (IntPtr)table);
            }
        }

        public static 
        void glColorTable(int target, int internalformat, Int32 width, int format, int type, [In, Out] object table)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorTable((int)target, (int)internalformat, (Int32)width, (int)format, (int)type, (IntPtr)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }
        }

        public static 
        void glColorTableParameterfv(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glColorTableParameterfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glColorTableParameterfv(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glColorTableParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glColorTableParameterfv(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glColorTableParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glColorTableParameteriv(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glColorTableParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glColorTableParameteriv(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glColorTableParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glColorTableParameteriv(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glColorTableParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glCopyColorTable(int target, int internalformat, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyColorTable((int)target, (int)internalformat, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void glGetColorTable(int target, int format, int type, [Out] IntPtr table)
        {
            unsafe
            {
                Delegates.glGetColorTable((int)target, (int)format, (int)type, (IntPtr)table);
            }
        }

        public static 
        void glGetColorTable(int target, int format, int type, [In, Out] object table)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetColorTable((int)target, (int)format, (int)type, (IntPtr)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }
        }

        public static 
        void glGetColorTableParameterfv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetColorTableParameterfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetColorTableParameterfv(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetColorTableParameterfv(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetColorTableParameteriv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetColorTableParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetColorTableParameteriv(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetColorTableParameteriv(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glColorSubTable(int target, Int32 start, Int32 count, int format, int type, IntPtr data)
        {
            unsafe
            {
                Delegates.glColorSubTable((int)target, (Int32)start, (Int32)count, (int)format, (int)type, (IntPtr)data);
            }
        }

        public static 
        void glColorSubTable(int target, Int32 start, Int32 count, int format, int type, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorSubTable((int)target, (Int32)start, (Int32)count, (int)format, (int)type, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCopyColorSubTable(int target, Int32 start, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyColorSubTable((int)target, (Int32)start, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void glConvolutionFilter1D(int target, int internalformat, Int32 width, int format, int type, IntPtr image)
        {
            unsafe
            {
                Delegates.glConvolutionFilter1D((int)target, (int)internalformat, (Int32)width, (int)format, (int)type, (IntPtr)image);
            }
        }

        public static 
        void glConvolutionFilter1D(int target, int internalformat, Int32 width, int format, int type, [In, Out] object image)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glConvolutionFilter1D((int)target, (int)internalformat, (Int32)width, (int)format, (int)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }

        public static 
        void glConvolutionFilter2D(int target, int internalformat, Int32 width, Int32 height, int format, int type, IntPtr image)
        {
            unsafe
            {
                Delegates.glConvolutionFilter2D((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)image);
            }
        }

        public static 
        void glConvolutionFilter2D(int target, int internalformat, Int32 width, Int32 height, int format, int type, [In, Out] object image)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glConvolutionFilter2D((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }

        public static 
        void glConvolutionParameterf(int target, int pname, Single @params)
        {
            Delegates.glConvolutionParameterf((int)target, (int)pname, (Single)@params);
        }

        public static 
        void glConvolutionParameterfv(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glConvolutionParameterfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glConvolutionParameterfv(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glConvolutionParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glConvolutionParameterfv(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glConvolutionParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glConvolutionParameteri(int target, int pname, Int32 @params)
        {
            Delegates.glConvolutionParameteri((int)target, (int)pname, (Int32)@params);
        }

        public static 
        void glConvolutionParameteriv(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glConvolutionParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glConvolutionParameteriv(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glConvolutionParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glConvolutionParameteriv(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glConvolutionParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glCopyConvolutionFilter1D(int target, int internalformat, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyConvolutionFilter1D((int)target, (int)internalformat, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void glCopyConvolutionFilter2D(int target, int internalformat, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyConvolutionFilter2D((int)target, (int)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void glGetConvolutionFilter(int target, int format, int type, [Out] IntPtr image)
        {
            unsafe
            {
                Delegates.glGetConvolutionFilter((int)target, (int)format, (int)type, (IntPtr)image);
            }
        }

        public static 
        void glGetConvolutionFilter(int target, int format, int type, [In, Out] object image)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetConvolutionFilter((int)target, (int)format, (int)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }

        public static 
        void glGetConvolutionParameterfv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetConvolutionParameterfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetConvolutionParameterfv(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetConvolutionParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetConvolutionParameterfv(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetConvolutionParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetConvolutionParameteriv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetConvolutionParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetConvolutionParameteriv(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetConvolutionParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetConvolutionParameteriv(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetConvolutionParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetSeparableFilter(int target, int format, int type, [Out] IntPtr row, [Out] IntPtr column, [Out] IntPtr span)
        {
            unsafe
            {
                Delegates.glGetSeparableFilter((int)target, (int)format, (int)type, (IntPtr)row, (IntPtr)column, (IntPtr)span);
            }
        }

        public static 
        void glGetSeparableFilter(int target, int format, int type, [Out] IntPtr row, [Out] IntPtr column, [In, Out] object span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((int)target, (int)format, (int)type, (IntPtr)row, (IntPtr)column, (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    span_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilter(int target, int format, int type, [Out] IntPtr row, [In, Out] object column, [Out] IntPtr span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((int)target, (int)format, (int)type, (IntPtr)row, (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span);
                }
                finally
                {
                    column_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilter(int target, int format, int type, [Out] IntPtr row, [In, Out] object column, [In, Out] object span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((int)target, (int)format, (int)type, (IntPtr)row, (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    column_ptr.Free();
                    span_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilter(int target, int format, int type, [In, Out] object row, [Out] IntPtr column, [Out] IntPtr span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((int)target, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column, (IntPtr)span);
                }
                finally
                {
                    row_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilter(int target, int format, int type, [In, Out] object row, [Out] IntPtr column, [In, Out] object span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((int)target, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column, (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    span_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilter(int target, int format, int type, [In, Out] object row, [In, Out] object column, [Out] IntPtr span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((int)target, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span);
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilter(int target, int format, int type, [In, Out] object row, [In, Out] object column, [In, Out] object span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilter((int)target, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                    span_ptr.Free();
                }
            }
        }

        public static 
        void glSeparableFilter2D(int target, int internalformat, Int32 width, Int32 height, int format, int type, IntPtr row, IntPtr column)
        {
            unsafe
            {
                Delegates.glSeparableFilter2D((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)row, (IntPtr)column);
            }
        }

        public static 
        void glSeparableFilter2D(int target, int internalformat, Int32 width, Int32 height, int format, int type, IntPtr row, [In, Out] object column)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2D((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)row, (IntPtr)column_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    column_ptr.Free();
                }
            }
        }

        public static 
        void glSeparableFilter2D(int target, int internalformat, Int32 width, Int32 height, int format, int type, [In, Out] object row, IntPtr column)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2D((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column);
                }
                finally
                {
                    row_ptr.Free();
                }
            }
        }

        public static 
        void glSeparableFilter2D(int target, int internalformat, Int32 width, Int32 height, int format, int type, [In, Out] object row, [In, Out] object column)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2D((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                }
            }
        }

        public static 
        void glGetHistogram(int target, Int32 reset, int format, int type, [Out] IntPtr values)
        {
            unsafe
            {
                Delegates.glGetHistogram((int)target, (Int32)reset, (int)format, (int)type, (IntPtr)values);
            }
        }

        public static 
        void glGetHistogram(int target, Int32 reset, int format, int type, [In, Out] object values)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle values_ptr = System.Runtime.InteropServices.GCHandle.Alloc(values, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetHistogram((int)target, (Int32)reset, (int)format, (int)type, (IntPtr)values_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    values_ptr.Free();
                }
            }
        }

        public static 
        void glGetHistogramParameterfv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetHistogramParameterfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetHistogramParameterfv(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetHistogramParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetHistogramParameterfv(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetHistogramParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetHistogramParameteriv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetHistogramParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetHistogramParameteriv(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetHistogramParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetHistogramParameteriv(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetHistogramParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMinmax(int target, Int32 reset, int format, int type, [Out] IntPtr values)
        {
            unsafe
            {
                Delegates.glGetMinmax((int)target, (Int32)reset, (int)format, (int)type, (IntPtr)values);
            }
        }

        public static 
        void glGetMinmax(int target, Int32 reset, int format, int type, [In, Out] object values)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle values_ptr = System.Runtime.InteropServices.GCHandle.Alloc(values, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetMinmax((int)target, (Int32)reset, (int)format, (int)type, (IntPtr)values_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    values_ptr.Free();
                }
            }
        }

        public static 
        void glGetMinmaxParameterfv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMinmaxParameterfv((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetMinmaxParameterfv(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetMinmaxParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMinmaxParameterfv(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetMinmaxParameterfv((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMinmaxParameteriv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMinmaxParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetMinmaxParameteriv(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetMinmaxParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMinmaxParameteriv(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetMinmaxParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glHistogram(int target, Int32 width, int internalformat, Int32 sink)
        {
            Delegates.glHistogram((int)target, (Int32)width, (int)internalformat, (Int32)sink);
        }

        public static 
        void glMinmax(int target, int internalformat, Int32 sink)
        {
            Delegates.glMinmax((int)target, (int)internalformat, (Int32)sink);
        }

        public static 
        void glResetHistogram(int target)
        {
            Delegates.glResetHistogram((int)target);
        }

        public static 
        void glResetMinmax(int target)
        {
            Delegates.glResetMinmax((int)target);
        }

        public static 
        void glTexImage3D(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexImage3D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexImage3D(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexImage3D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glTexSubImage3D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexSubImage3D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexSubImage3D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage3D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glCopyTexSubImage3D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyTexSubImage3D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void glActiveTexture(int texture)
        {
            Delegates.glActiveTexture((int)texture);
        }

        public static 
        void glClientActiveTexture(int texture)
        {
            Delegates.glClientActiveTexture((int)texture);
        }

        public static 
        void glMultiTexCoord1d(int target, Double s)
        {
            Delegates.glMultiTexCoord1d((int)target, (Double)s);
        }

        public static 
        void glMultiTexCoord1dv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1dv((int)target, (Double*)v);
            }
        }

        public static 
        void glMultiTexCoord1dv(int target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1dv((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1dv(int target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1dv((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1f(int target, Single s)
        {
            Delegates.glMultiTexCoord1f((int)target, (Single)s);
        }

        public static 
        void glMultiTexCoord1fv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1fv((int)target, (Single*)v);
            }
        }

        public static 
        void glMultiTexCoord1fv(int target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1fv((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1fv(int target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1fv((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1i(int target, Int32 s)
        {
            Delegates.glMultiTexCoord1i((int)target, (Int32)s);
        }

        public static 
        void glMultiTexCoord1iv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1iv((int)target, (Int32*)v);
            }
        }

        public static 
        void glMultiTexCoord1iv(int target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1iv((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1iv(int target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1iv((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1s(int target, Int16 s)
        {
            Delegates.glMultiTexCoord1s((int)target, (Int16)s);
        }

        public static 
        void glMultiTexCoord1sv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1sv((int)target, (Int16*)v);
            }
        }

        public static 
        void glMultiTexCoord1sv(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1sv((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1sv(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1sv((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2d(int target, Double s, Double t)
        {
            Delegates.glMultiTexCoord2d((int)target, (Double)s, (Double)t);
        }

        public static 
        void glMultiTexCoord2dv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2dv((int)target, (Double*)v);
            }
        }

        public static 
        void glMultiTexCoord2dv(int target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2dv((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2dv(int target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2dv((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2f(int target, Single s, Single t)
        {
            Delegates.glMultiTexCoord2f((int)target, (Single)s, (Single)t);
        }

        public static 
        void glMultiTexCoord2fv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2fv((int)target, (Single*)v);
            }
        }

        public static 
        void glMultiTexCoord2fv(int target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2fv((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2fv(int target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2fv((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2i(int target, Int32 s, Int32 t)
        {
            Delegates.glMultiTexCoord2i((int)target, (Int32)s, (Int32)t);
        }

        public static 
        void glMultiTexCoord2iv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2iv((int)target, (Int32*)v);
            }
        }

        public static 
        void glMultiTexCoord2iv(int target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2iv((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2iv(int target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2iv((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2s(int target, Int16 s, Int16 t)
        {
            Delegates.glMultiTexCoord2s((int)target, (Int16)s, (Int16)t);
        }

        public static 
        void glMultiTexCoord2sv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2sv((int)target, (Int16*)v);
            }
        }

        public static 
        void glMultiTexCoord2sv(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2sv((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2sv(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2sv((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3d(int target, Double s, Double t, Double r)
        {
            Delegates.glMultiTexCoord3d((int)target, (Double)s, (Double)t, (Double)r);
        }

        public static 
        void glMultiTexCoord3dv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3dv((int)target, (Double*)v);
            }
        }

        public static 
        void glMultiTexCoord3dv(int target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3dv((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3dv(int target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3dv((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3f(int target, Single s, Single t, Single r)
        {
            Delegates.glMultiTexCoord3f((int)target, (Single)s, (Single)t, (Single)r);
        }

        public static 
        void glMultiTexCoord3fv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3fv((int)target, (Single*)v);
            }
        }

        public static 
        void glMultiTexCoord3fv(int target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3fv((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3fv(int target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3fv((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3i(int target, Int32 s, Int32 t, Int32 r)
        {
            Delegates.glMultiTexCoord3i((int)target, (Int32)s, (Int32)t, (Int32)r);
        }

        public static 
        void glMultiTexCoord3iv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3iv((int)target, (Int32*)v);
            }
        }

        public static 
        void glMultiTexCoord3iv(int target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3iv((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3iv(int target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3iv((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3s(int target, Int16 s, Int16 t, Int16 r)
        {
            Delegates.glMultiTexCoord3s((int)target, (Int16)s, (Int16)t, (Int16)r);
        }

        public static 
        void glMultiTexCoord3sv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3sv((int)target, (Int16*)v);
            }
        }

        public static 
        void glMultiTexCoord3sv(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3sv((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3sv(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3sv((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4d(int target, Double s, Double t, Double r, Double q)
        {
            Delegates.glMultiTexCoord4d((int)target, (Double)s, (Double)t, (Double)r, (Double)q);
        }

        public static 
        void glMultiTexCoord4dv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4dv((int)target, (Double*)v);
            }
        }

        public static 
        void glMultiTexCoord4dv(int target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4dv((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4dv(int target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4dv((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4f(int target, Single s, Single t, Single r, Single q)
        {
            Delegates.glMultiTexCoord4f((int)target, (Single)s, (Single)t, (Single)r, (Single)q);
        }

        public static 
        void glMultiTexCoord4fv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4fv((int)target, (Single*)v);
            }
        }

        public static 
        void glMultiTexCoord4fv(int target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4fv((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4fv(int target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4fv((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4i(int target, Int32 s, Int32 t, Int32 r, Int32 q)
        {
            Delegates.glMultiTexCoord4i((int)target, (Int32)s, (Int32)t, (Int32)r, (Int32)q);
        }

        public static 
        void glMultiTexCoord4iv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4iv((int)target, (Int32*)v);
            }
        }

        public static 
        void glMultiTexCoord4iv(int target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4iv((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4iv(int target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4iv((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4s(int target, Int16 s, Int16 t, Int16 r, Int16 q)
        {
            Delegates.glMultiTexCoord4s((int)target, (Int16)s, (Int16)t, (Int16)r, (Int16)q);
        }

        public static 
        void glMultiTexCoord4sv(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4sv((int)target, (Int16*)v);
            }
        }

        public static 
        void glMultiTexCoord4sv(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4sv((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4sv(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4sv((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glLoadTransposeMatrixf(IntPtr m)
        {
            unsafe
            {
                Delegates.glLoadTransposeMatrixf((Single*)m);
            }
        }

        public static 
        void glLoadTransposeMatrixf(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glLoadTransposeMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void glLoadTransposeMatrixf(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glLoadTransposeMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void glLoadTransposeMatrixd(IntPtr m)
        {
            unsafe
            {
                Delegates.glLoadTransposeMatrixd((Double*)m);
            }
        }

        public static 
        void glLoadTransposeMatrixd(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glLoadTransposeMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void glLoadTransposeMatrixd(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glLoadTransposeMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void glMultTransposeMatrixf(IntPtr m)
        {
            unsafe
            {
                Delegates.glMultTransposeMatrixf((Single*)m);
            }
        }

        public static 
        void glMultTransposeMatrixf(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glMultTransposeMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void glMultTransposeMatrixf(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glMultTransposeMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void glMultTransposeMatrixd(IntPtr m)
        {
            unsafe
            {
                Delegates.glMultTransposeMatrixd((Double*)m);
            }
        }

        public static 
        void glMultTransposeMatrixd(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glMultTransposeMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void glMultTransposeMatrixd(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glMultTransposeMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void glSampleCoverage(Single value, Int32 invert)
        {
            Delegates.glSampleCoverage((Single)value, (Int32)invert);
        }

        public static 
        void glCompressedTexImage3D(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexImage3D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexImage3D(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage3D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexImage2D(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexImage2D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexImage2D(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage2D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexImage1D(int target, Int32 level, int internalformat, Int32 width, Int32 border, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexImage1D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexImage1D(int target, Int32 level, int internalformat, Int32 width, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage1D((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexSubImage3D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, int format, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexSubImage3D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (int)format, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexSubImage3D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, int format, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage3D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (int)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexSubImage2D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, int format, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexSubImage2D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (int)format, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexSubImage2D(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, int format, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage2D((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (int)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexSubImage1D(int target, Int32 level, Int32 xoffset, Int32 width, int format, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexSubImage1D((int)target, (Int32)level, (Int32)xoffset, (Int32)width, (int)format, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexSubImage1D(int target, Int32 level, Int32 xoffset, Int32 width, int format, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage1D((int)target, (Int32)level, (Int32)xoffset, (Int32)width, (int)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glGetCompressedTexImage(int target, Int32 level, [Out] IntPtr img)
        {
            unsafe
            {
                Delegates.glGetCompressedTexImage((int)target, (Int32)level, (IntPtr)img);
            }
        }

        public static 
        void glGetCompressedTexImage(int target, Int32 level, [In, Out] object img)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle img_ptr = System.Runtime.InteropServices.GCHandle.Alloc(img, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetCompressedTexImage((int)target, (Int32)level, (IntPtr)img_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    img_ptr.Free();
                }
            }
        }

        public static 
        void glBlendFuncSeparate(int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dfactorAlpha)
        {
            Delegates.glBlendFuncSeparate((int)sfactorRGB, (int)dfactorRGB, (int)sfactorAlpha, (int)dfactorAlpha);
        }

        public static 
        void glFogCoordf(Single coord)
        {
            Delegates.glFogCoordf((Single)coord);
        }

        public static 
        void glFogCoordfv(IntPtr coord)
        {
            unsafe
            {
                Delegates.glFogCoordfv((Single*)coord);
            }
        }

        public static 
        void glFogCoordfv(Single[] coord)
        {
            unsafe
            {
                fixed (Single* coord_ptr = coord)
                {
                    Delegates.glFogCoordfv((Single*)coord_ptr);
                }
            }
        }

        public static 
        void glFogCoordfv(ref Single coord)
        {
            unsafe
            {
                fixed (Single* coord_ptr = &coord)
                {
                    Delegates.glFogCoordfv((Single*)coord_ptr);
                }
            }
        }

        public static 
        void glFogCoordd(Double coord)
        {
            Delegates.glFogCoordd((Double)coord);
        }

        public static 
        void glFogCoorddv(IntPtr coord)
        {
            unsafe
            {
                Delegates.glFogCoorddv((Double*)coord);
            }
        }

        public static 
        void glFogCoorddv(Double[] coord)
        {
            unsafe
            {
                fixed (Double* coord_ptr = coord)
                {
                    Delegates.glFogCoorddv((Double*)coord_ptr);
                }
            }
        }

        public static 
        void glFogCoorddv(ref Double coord)
        {
            unsafe
            {
                fixed (Double* coord_ptr = &coord)
                {
                    Delegates.glFogCoorddv((Double*)coord_ptr);
                }
            }
        }

        public static 
        void glFogCoordPointer(int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glFogCoordPointer((int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glFogCoordPointer(int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glFogCoordPointer((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] IntPtr first, [Out] IntPtr count, Int32 primcount)
        {
            unsafe
            {
                Delegates.glMultiDrawArrays((int)mode, (Int32*)first, (Int32*)count, (Int32)primcount);
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] IntPtr first, [Out] Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawArrays((int)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] IntPtr first, [Out] out Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawArrays((int)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] Int32[] first, [Out] IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                {
                    Delegates.glMultiDrawArrays((int)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] Int32[] first, [Out] Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawArrays((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] Int32[] first, [Out] out Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawArrays((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] out Int32 first, [Out] IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                {
                    Delegates.glMultiDrawArrays((int)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                    first = *first_ptr;
                }
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] out Int32 first, [Out] Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawArrays((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    first = *first_ptr;
                }
            }
        }

        public static 
        void glMultiDrawArrays(int mode, [Out] out Int32 first, [Out] out Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawArrays((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    first = *first_ptr;
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glMultiDrawElements(int mode, IntPtr count, int type, IntPtr indices, Int32 primcount)
        {
            unsafe
            {
                Delegates.glMultiDrawElements((int)mode, (Int32*)count, (int)type, (IntPtr)indices, (Int32)primcount);
            }
        }

        public static 
        void glMultiDrawElements(int mode, IntPtr count, int type, [In, Out] object indices, Int32 primcount)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMultiDrawElements((int)mode, (Int32*)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        public static 
        void glMultiDrawElements(int mode, Int32[] count, int type, IntPtr indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawElements((int)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElements(int mode, Int32[] count, int type, [In, Out] object indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiDrawElements((int)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiDrawElements(int mode, ref Int32 count, int type, IntPtr indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawElements((int)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElements(int mode, ref Int32 count, int type, [In, Out] object indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiDrawElements((int)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glPointParameterf(int pname, Single param)
        {
            Delegates.glPointParameterf((int)pname, (Single)param);
        }

        public static 
        void glPointParameterfv(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPointParameterfv((int)pname, (Single*)@params);
            }
        }

        public static 
        void glPointParameterfv(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glPointParameterfv((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glPointParameterfv(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glPointParameterfv((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glPointParameteri(int pname, Int32 param)
        {
            Delegates.glPointParameteri((int)pname, (Int32)param);
        }

        public static 
        void glPointParameteriv(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPointParameteriv((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glPointParameteriv(int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glPointParameteriv((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glPointParameteriv(int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glPointParameteriv((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3b(SByte red, SByte green, SByte blue)
        {
            Delegates.glSecondaryColor3b((SByte)red, (SByte)green, (SByte)blue);
        }

        public static 
        void glSecondaryColor3b(Byte red, Byte green, Byte blue)
        {
            Delegates.glSecondaryColor3b((SByte)red, (SByte)green, (SByte)blue);
        }

        public static 
        void glSecondaryColor3bv(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3bv((SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3bv(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3bv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3bv(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3bv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3d(Double red, Double green, Double blue)
        {
            Delegates.glSecondaryColor3d((Double)red, (Double)green, (Double)blue);
        }

        public static 
        void glSecondaryColor3dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3dv((Double*)v);
            }
        }

        public static 
        void glSecondaryColor3dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glSecondaryColor3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3f(Single red, Single green, Single blue)
        {
            Delegates.glSecondaryColor3f((Single)red, (Single)green, (Single)blue);
        }

        public static 
        void glSecondaryColor3fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3fv((Single*)v);
            }
        }

        public static 
        void glSecondaryColor3fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glSecondaryColor3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3i(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glSecondaryColor3i((Int32)red, (Int32)green, (Int32)blue);
        }

        public static 
        void glSecondaryColor3iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3iv((Int32*)v);
            }
        }

        public static 
        void glSecondaryColor3iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3s(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glSecondaryColor3s((Int16)red, (Int16)green, (Int16)blue);
        }

        public static 
        void glSecondaryColor3sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3sv((Int16*)v);
            }
        }

        public static 
        void glSecondaryColor3sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3ub(Byte red, Byte green, Byte blue)
        {
            Delegates.glSecondaryColor3ub((Byte)red, (Byte)green, (Byte)blue);
        }

        public static 
        void glSecondaryColor3ubv(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3ubv((Byte*)v);
            }
        }

        public static 
        void glSecondaryColor3ubv(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3ubv((Byte*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3ubv(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3ubv((Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3ui(UInt32 red, UInt32 green, UInt32 blue)
        {
            Delegates.glSecondaryColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        public static 
        void glSecondaryColor3ui(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glSecondaryColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        public static 
        void glSecondaryColor3uiv(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3uiv((UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3uiv(UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3uiv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3uiv(ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3uiv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3us(UInt16 red, UInt16 green, UInt16 blue)
        {
            Delegates.glSecondaryColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glSecondaryColor3us(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glSecondaryColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glSecondaryColor3usv(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3usv((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3usv(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3usv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3usv(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3usv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColorPointer(Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glSecondaryColorPointer((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glSecondaryColorPointer(Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSecondaryColorPointer((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glWindowPos2d(Double x, Double y)
        {
            Delegates.glWindowPos2d((Double)x, (Double)y);
        }

        public static 
        void glWindowPos2dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2dv((Double*)v);
            }
        }

        public static 
        void glWindowPos2dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2f(Single x, Single y)
        {
            Delegates.glWindowPos2f((Single)x, (Single)y);
        }

        public static 
        void glWindowPos2fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2fv((Single*)v);
            }
        }

        public static 
        void glWindowPos2fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2i(Int32 x, Int32 y)
        {
            Delegates.glWindowPos2i((Int32)x, (Int32)y);
        }

        public static 
        void glWindowPos2iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2iv((Int32*)v);
            }
        }

        public static 
        void glWindowPos2iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2s(Int16 x, Int16 y)
        {
            Delegates.glWindowPos2s((Int16)x, (Int16)y);
        }

        public static 
        void glWindowPos2sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2sv((Int16*)v);
            }
        }

        public static 
        void glWindowPos2sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3d(Double x, Double y, Double z)
        {
            Delegates.glWindowPos3d((Double)x, (Double)y, (Double)z);
        }

        public static 
        void glWindowPos3dv(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3dv((Double*)v);
            }
        }

        public static 
        void glWindowPos3dv(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3dv(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3f(Single x, Single y, Single z)
        {
            Delegates.glWindowPos3f((Single)x, (Single)y, (Single)z);
        }

        public static 
        void glWindowPos3fv(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3fv((Single*)v);
            }
        }

        public static 
        void glWindowPos3fv(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3fv(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3i(Int32 x, Int32 y, Int32 z)
        {
            Delegates.glWindowPos3i((Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void glWindowPos3iv(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3iv((Int32*)v);
            }
        }

        public static 
        void glWindowPos3iv(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3iv(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3s(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glWindowPos3s((Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glWindowPos3sv(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3sv((Int16*)v);
            }
        }

        public static 
        void glWindowPos3sv(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3sv(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glGenQueries(Int32 n, [Out] IntPtr ids)
        {
            unsafe
            {
                Delegates.glGenQueries((Int32)n, (UInt32*)ids);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenQueries(Int32 n, [Out] UInt32[] ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = ids)
                {
                    Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glGenQueries(Int32 n, [Out] Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenQueries(Int32 n, [Out] out UInt32 ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = &ids)
                {
                    Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }

        public static 
        void glGenQueries(Int32 n, [Out] out Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }

        public static 
        void glDeleteQueries(Int32 n, IntPtr ids)
        {
            unsafe
            {
                Delegates.glDeleteQueries((Int32)n, (UInt32*)ids);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteQueries(Int32 n, UInt32[] ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = ids)
                {
                    Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glDeleteQueries(Int32 n, Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteQueries(Int32 n, ref UInt32 ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = &ids)
                {
                    Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glDeleteQueries(Int32 n, ref Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsQuery(UInt32 id)
        {
            return Delegates.glIsQuery((UInt32)id);
        }

        public static 
        Int32 glIsQuery(Int32 id)
        {
            return Delegates.glIsQuery((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBeginQuery(int target, UInt32 id)
        {
            Delegates.glBeginQuery((int)target, (UInt32)id);
        }

        public static 
        void glBeginQuery(int target, Int32 id)
        {
            Delegates.glBeginQuery((int)target, (UInt32)id);
        }

        public static 
        void glEndQuery(int target)
        {
            Delegates.glEndQuery((int)target);
        }

        public static 
        void glGetQueryiv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryiv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetQueryiv(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryiv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetQueryiv(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryiv((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectiv(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectiv((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetQueryObjectiv(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectiv((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectiv(UInt32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectiv((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetQueryObjectiv(Int32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectiv((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectiv(UInt32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectiv((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetQueryObjectiv(Int32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectiv((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectuiv(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectuiv((UInt32)id, (int)pname, (UInt32*)@params);
            }
        }

        public static 
        void glGetQueryObjectuiv(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectuiv((UInt32)id, (int)pname, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectuiv(UInt32 id, int pname, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectuiv((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetQueryObjectuiv(Int32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectuiv((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectuiv(UInt32 id, int pname, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectuiv((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetQueryObjectuiv(Int32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectuiv((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindBuffer(int target, UInt32 buffer)
        {
            Delegates.glBindBuffer((int)target, (UInt32)buffer);
        }

        public static 
        void glBindBuffer(int target, Int32 buffer)
        {
            Delegates.glBindBuffer((int)target, (UInt32)buffer);
        }

        public static 
        void glDeleteBuffers(Int32 n, IntPtr buffers)
        {
            unsafe
            {
                Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteBuffers(Int32 n, UInt32[] buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = buffers)
                {
                    Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void glDeleteBuffers(Int32 n, Int32[] buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteBuffers(Int32 n, ref UInt32 buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = &buffers)
                {
                    Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void glDeleteBuffers(Int32 n, ref Int32 buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void glGenBuffers(Int32 n, [Out] IntPtr buffers)
        {
            unsafe
            {
                Delegates.glGenBuffers((Int32)n, (UInt32*)buffers);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenBuffers(Int32 n, [Out] UInt32[] buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = buffers)
                {
                    Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void glGenBuffers(Int32 n, [Out] Int32[] buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenBuffers(Int32 n, [Out] out UInt32 buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = &buffers)
                {
                    Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
                    buffers = *buffers_ptr;
                }
            }
        }

        public static 
        void glGenBuffers(Int32 n, [Out] out Int32 buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
                    buffers = *buffers_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsBuffer(UInt32 buffer)
        {
            return Delegates.glIsBuffer((UInt32)buffer);
        }

        public static 
        Int32 glIsBuffer(Int32 buffer)
        {
            return Delegates.glIsBuffer((UInt32)buffer);
        }

        public static 
        void glBufferData(int target, IntPtr size, IntPtr data, int usage)
        {
            unsafe
            {
                Delegates.glBufferData((int)target, (IntPtr)size, (IntPtr)data, (int)usage);
            }
        }

        public static 
        void glBufferData(int target, IntPtr size, [In, Out] object data, int usage)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glBufferData((int)target, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject(), (int)usage);
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glBufferSubData(int target, IntPtr offset, IntPtr size, IntPtr data)
        {
            unsafe
            {
                Delegates.glBufferSubData((int)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
            }
        }

        public static 
        void glBufferSubData(int target, IntPtr offset, IntPtr size, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glBufferSubData((int)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glGetBufferSubData(int target, IntPtr offset, IntPtr size, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetBufferSubData((int)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
            }
        }

        public static 
        void glGetBufferSubData(int target, IntPtr offset, IntPtr size, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetBufferSubData((int)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        IntPtr glMapBuffer(int target, int access)
        {
            return Delegates.glMapBuffer((int)target, (int)access);
        }

        public static 
        Int32 glUnmapBuffer(int target)
        {
            return Delegates.glUnmapBuffer((int)target);
        }

        public static 
        void glGetBufferParameteriv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetBufferParameteriv((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetBufferParameteriv(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetBufferParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetBufferParameteriv(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetBufferParameteriv((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetBufferPointerv(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetBufferPointerv((int)target, (int)pname, (IntPtr)@params);
            }
        }

        public static 
        void glGetBufferPointerv(int target, int pname, [In, Out] object @params)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetBufferPointerv((int)target, (int)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }
        }

        public static 
        void glBlendEquationSeparate(int modeRGB, int modeAlpha)
        {
            Delegates.glBlendEquationSeparate((int)modeRGB, (int)modeAlpha);
        }

        public static 
        void glDrawBuffers(Int32 n, IntPtr bufs)
        {
            unsafe
            {
                Delegates.glDrawBuffers((Int32)n, (int*)bufs);
            }
        }

        public static 
        void glDrawBuffers(Int32 n, int[] bufs)
        {
            unsafe
            {
                fixed (int* bufs_ptr = bufs)
                {
                    Delegates.glDrawBuffers((Int32)n, (int*)bufs_ptr);
                }
            }
        }

        public static 
        void glDrawBuffers(Int32 n, ref int bufs)
        {
            unsafe
            {
                fixed (int* bufs_ptr = &bufs)
                {
                    Delegates.glDrawBuffers((Int32)n, (int*)bufs_ptr);
                }
            }
        }

        public static 
        void glStencilOpSeparate(int face, int sfail, int dpfail, int dppass)
        {
            Delegates.glStencilOpSeparate((int)face, (int)sfail, (int)dpfail, (int)dppass);
        }

        [System.CLSCompliant(false)]
        public static 
        void glStencilFuncSeparate(int frontfunc, int backfunc, Int32 @ref, UInt32 mask)
        {
            Delegates.glStencilFuncSeparate((int)frontfunc, (int)backfunc, (Int32)@ref, (UInt32)mask);
        }

        public static 
        void glStencilFuncSeparate(int frontfunc, int backfunc, Int32 @ref, Int32 mask)
        {
            Delegates.glStencilFuncSeparate((int)frontfunc, (int)backfunc, (Int32)@ref, (UInt32)mask);
        }

        [System.CLSCompliant(false)]
        public static 
        void glStencilMaskSeparate(int face, UInt32 mask)
        {
            Delegates.glStencilMaskSeparate((int)face, (UInt32)mask);
        }

        public static 
        void glStencilMaskSeparate(int face, Int32 mask)
        {
            Delegates.glStencilMaskSeparate((int)face, (UInt32)mask);
        }

        [System.CLSCompliant(false)]
        public static 
        void glAttachShader(UInt32 program, UInt32 shader)
        {
            Delegates.glAttachShader((UInt32)program, (UInt32)shader);
        }

        public static 
        void glAttachShader(Int32 program, Int32 shader)
        {
            Delegates.glAttachShader((UInt32)program, (UInt32)shader);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindAttribLocation(UInt32 program, UInt32 index, System.String name)
        {
            Delegates.glBindAttribLocation((UInt32)program, (UInt32)index, (System.String)name);
        }

        public static 
        void glBindAttribLocation(Int32 program, Int32 index, System.String name)
        {
            Delegates.glBindAttribLocation((UInt32)program, (UInt32)index, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void glCompileShader(UInt32 shader)
        {
            Delegates.glCompileShader((UInt32)shader);
        }

        public static 
        void glCompileShader(Int32 shader)
        {
            Delegates.glCompileShader((UInt32)shader);
        }

        public static 
        Int32 glCreateProgram()
        {
            return Delegates.glCreateProgram();
        }

        public static 
        Int32 glCreateShader(int type)
        {
            return Delegates.glCreateShader((int)type);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteProgram(UInt32 program)
        {
            Delegates.glDeleteProgram((UInt32)program);
        }

        public static 
        void glDeleteProgram(Int32 program)
        {
            Delegates.glDeleteProgram((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteShader(UInt32 shader)
        {
            Delegates.glDeleteShader((UInt32)shader);
        }

        public static 
        void glDeleteShader(Int32 shader)
        {
            Delegates.glDeleteShader((UInt32)shader);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDetachShader(UInt32 program, UInt32 shader)
        {
            Delegates.glDetachShader((UInt32)program, (UInt32)shader);
        }

        public static 
        void glDetachShader(Int32 program, Int32 shader)
        {
            Delegates.glDetachShader((UInt32)program, (UInt32)shader);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDisableVertexAttribArray(UInt32 index)
        {
            Delegates.glDisableVertexAttribArray((UInt32)index);
        }

        public static 
        void glDisableVertexAttribArray(Int32 index)
        {
            Delegates.glDisableVertexAttribArray((UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        void glEnableVertexAttribArray(UInt32 index)
        {
            Delegates.glEnableVertexAttribArray((UInt32)index);
        }

        public static 
        void glEnableVertexAttribArray(Int32 index)
        {
            Delegates.glEnableVertexAttribArray((UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] IntPtr count, [Out] IntPtr obj)
        {
            unsafe
            {
                Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] IntPtr count, [Out] IntPtr obj)
        {
            unsafe
            {
                Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] IntPtr count, [Out] UInt32[] obj)
        {
            unsafe
            {
                fixed (UInt32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
                }
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] IntPtr count, [Out] Int32[] obj)
        {
            unsafe
            {
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] IntPtr count, [Out] out UInt32 obj)
        {
            unsafe
            {
                fixed (UInt32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] IntPtr count, [Out] out Int32 obj)
        {
            unsafe
            {
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] Int32[] count, [Out] IntPtr obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
                }
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] Int32[] count, [Out] IntPtr obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] Int32[] count, [Out] UInt32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (UInt32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                }
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] Int32[] count, [Out] Int32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] Int32[] count, [Out] out UInt32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (UInt32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] Int32[] count, [Out] out Int32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] out Int32 count, [Out] IntPtr obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] out Int32 count, [Out] IntPtr obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
                    count = *count_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] out Int32 count, [Out] UInt32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (UInt32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] out Int32 count, [Out] Int32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedShaders(UInt32 program, Int32 maxCount, [Out] out Int32 count, [Out] out UInt32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (UInt32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                    obj = *obj_ptr;
                }
            }
        }

        public static 
        void glGetAttachedShaders(Int32 program, Int32 maxCount, [Out] out Int32 count, [Out] out Int32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                    obj = *obj_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGetAttribLocation(UInt32 program, System.String name)
        {
            return Delegates.glGetAttribLocation((UInt32)program, (System.String)name);
        }

        public static 
        Int32 glGetAttribLocation(Int32 program, System.String name)
        {
            return Delegates.glGetAttribLocation((UInt32)program, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramiv(UInt32 program, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramiv((UInt32)program, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetProgramiv(Int32 program, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramiv((UInt32)program, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramiv(UInt32 program, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramiv((UInt32)program, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramiv(Int32 program, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramiv((UInt32)program, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramiv(UInt32 program, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramiv((UInt32)program, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramiv(Int32 program, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramiv((UInt32)program, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramInfoLog(UInt32 program, Int32 bufSize, [Out] IntPtr length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
            }
        }

        public static 
        void glGetProgramInfoLog(Int32 program, Int32 bufSize, [Out] IntPtr length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramInfoLog(UInt32 program, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        public static 
        void glGetProgramInfoLog(Int32 program, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramInfoLog(UInt32 program, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetProgramInfoLog(Int32 program, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderiv(UInt32 shader, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetShaderiv((UInt32)shader, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetShaderiv(Int32 shader, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetShaderiv((UInt32)shader, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderiv(UInt32 shader, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetShaderiv((UInt32)shader, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetShaderiv(Int32 shader, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetShaderiv((UInt32)shader, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderiv(UInt32 shader, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetShaderiv((UInt32)shader, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetShaderiv(Int32 shader, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetShaderiv((UInt32)shader, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderInfoLog(UInt32 shader, Int32 bufSize, [Out] IntPtr length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
            }
        }

        public static 
        void glGetShaderInfoLog(Int32 shader, Int32 bufSize, [Out] IntPtr length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderInfoLog(UInt32 shader, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        public static 
        void glGetShaderInfoLog(Int32 shader, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderInfoLog(UInt32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetShaderInfoLog(Int32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderSource(UInt32 shader, Int32 bufSize, [Out] IntPtr length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder[])source);
            }
        }

        public static 
        void glGetShaderSource(Int32 shader, Int32 bufSize, [Out] IntPtr length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder[])source);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderSource(UInt32 shader, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                }
            }
        }

        public static 
        void glGetShaderSource(Int32 shader, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderSource(UInt32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetShaderSource(Int32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGetUniformLocation(UInt32 program, System.String name)
        {
            return Delegates.glGetUniformLocation((UInt32)program, (System.String)name);
        }

        public static 
        Int32 glGetUniformLocation(Int32 program, System.String name)
        {
            return Delegates.glGetUniformLocation((UInt32)program, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformfv(UInt32 program, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params);
            }
        }

        public static 
        void glGetUniformfv(Int32 program, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformfv(UInt32 program, Int32 location, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetUniformfv(Int32 program, Int32 location, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformfv(UInt32 program, Int32 location, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetUniformfv(Int32 program, Int32 location, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformiv(UInt32 program, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params);
            }
        }

        public static 
        void glGetUniformiv(Int32 program, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformiv(UInt32 program, Int32 location, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetUniformiv(Int32 program, Int32 location, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformiv(UInt32 program, Int32 location, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetUniformiv(Int32 program, Int32 location, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdv(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribdv((UInt32)index, (int)pname, (Double*)@params);
            }
        }

        public static 
        void glGetVertexAttribdv(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribdv((UInt32)index, (int)pname, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdv(UInt32 index, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdv((UInt32)index, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribdv(Int32 index, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdv((UInt32)index, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdv(UInt32 index, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdv((UInt32)index, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribdv(Int32 index, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdv((UInt32)index, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfv(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribfv((UInt32)index, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetVertexAttribfv(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribfv((UInt32)index, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfv(UInt32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfv((UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribfv(Int32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfv((UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfv(UInt32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfv((UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribfv(Int32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfv((UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribiv(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribiv((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetVertexAttribiv(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribiv((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribiv(UInt32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribiv((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribiv(Int32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribiv((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribiv(UInt32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribiv((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribiv(Int32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribiv((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribPointerv(UInt32 index, int pname, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glGetVertexAttribPointerv((UInt32)index, (int)pname, (IntPtr)pointer);
            }
        }

        public static 
        void glGetVertexAttribPointerv(Int32 index, int pname, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glGetVertexAttribPointerv((UInt32)index, (int)pname, (IntPtr)pointer);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribPointerv(UInt32 index, int pname, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointerv((UInt32)index, (int)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glGetVertexAttribPointerv(Int32 index, int pname, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointerv((UInt32)index, (int)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsProgram(UInt32 program)
        {
            return Delegates.glIsProgram((UInt32)program);
        }

        public static 
        Int32 glIsProgram(Int32 program)
        {
            return Delegates.glIsProgram((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsShader(UInt32 shader)
        {
            return Delegates.glIsShader((UInt32)shader);
        }

        public static 
        Int32 glIsShader(Int32 shader)
        {
            return Delegates.glIsShader((UInt32)shader);
        }

        [System.CLSCompliant(false)]
        public static 
        void glLinkProgram(UInt32 program)
        {
            Delegates.glLinkProgram((UInt32)program);
        }

        public static 
        void glLinkProgram(Int32 program)
        {
            Delegates.glLinkProgram((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderSource(UInt32 shader, Int32 count, System.String[] @string, IntPtr length)
        {
            unsafe
            {
                Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length);
            }
        }

        public static 
        void glShaderSource(Int32 shader, Int32 count, System.String[] @string, IntPtr length)
        {
            unsafe
            {
                Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderSource(UInt32 shader, Int32 count, System.String[] @string, Int32[] length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        public static 
        void glShaderSource(Int32 shader, Int32 count, System.String[] @string, Int32[] length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderSource(UInt32 shader, Int32 count, System.String[] @string, ref Int32 length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        public static 
        void glShaderSource(Int32 shader, Int32 count, System.String[] @string, ref Int32 length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUseProgram(UInt32 program)
        {
            Delegates.glUseProgram((UInt32)program);
        }

        public static 
        void glUseProgram(Int32 program)
        {
            Delegates.glUseProgram((UInt32)program);
        }

        public static 
        void glUniform1f(Int32 location, Single v0)
        {
            Delegates.glUniform1f((Int32)location, (Single)v0);
        }

        public static 
        void glUniform2f(Int32 location, Single v0, Single v1)
        {
            Delegates.glUniform2f((Int32)location, (Single)v0, (Single)v1);
        }

        public static 
        void glUniform3f(Int32 location, Single v0, Single v1, Single v2)
        {
            Delegates.glUniform3f((Int32)location, (Single)v0, (Single)v1, (Single)v2);
        }

        public static 
        void glUniform4f(Int32 location, Single v0, Single v1, Single v2, Single v3)
        {
            Delegates.glUniform4f((Int32)location, (Single)v0, (Single)v1, (Single)v2, (Single)v3);
        }

        public static 
        void glUniform1i(Int32 location, Int32 v0)
        {
            Delegates.glUniform1i((Int32)location, (Int32)v0);
        }

        public static 
        void glUniform2i(Int32 location, Int32 v0, Int32 v1)
        {
            Delegates.glUniform2i((Int32)location, (Int32)v0, (Int32)v1);
        }

        public static 
        void glUniform3i(Int32 location, Int32 v0, Int32 v1, Int32 v2)
        {
            Delegates.glUniform3i((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2);
        }

        public static 
        void glUniform4i(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
        {
            Delegates.glUniform4i((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2, (Int32)v3);
        }

        public static 
        void glUniform1fv(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value);
            }
        }

        public static 
        void glUniform1fv(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform1fv(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2fv(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value);
            }
        }

        public static 
        void glUniform2fv(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2fv(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3fv(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value);
            }
        }

        public static 
        void glUniform3fv(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3fv(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4fv(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value);
            }
        }

        public static 
        void glUniform4fv(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4fv(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform1iv(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value);
            }
        }

        public static 
        void glUniform1iv(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform1iv(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2iv(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value);
            }
        }

        public static 
        void glUniform2iv(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2iv(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3iv(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value);
            }
        }

        public static 
        void glUniform3iv(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3iv(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4iv(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value);
            }
        }

        public static 
        void glUniform4iv(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4iv(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix2fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix2fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix2fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix3fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix3fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix3fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix4fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix4fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix4fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glValidateProgram(UInt32 program)
        {
            Delegates.glValidateProgram((UInt32)program);
        }

        public static 
        void glValidateProgram(Int32 program)
        {
            Delegates.glValidateProgram((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1d(UInt32 index, Double x)
        {
            Delegates.glVertexAttrib1d((UInt32)index, (Double)x);
        }

        public static 
        void glVertexAttrib1d(Int32 index, Double x)
        {
            Delegates.glVertexAttrib1d((UInt32)index, (Double)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib1dv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dv(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1dv(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dv(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1dv(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1f(UInt32 index, Single x)
        {
            Delegates.glVertexAttrib1f((UInt32)index, (Single)x);
        }

        public static 
        void glVertexAttrib1f(Int32 index, Single x)
        {
            Delegates.glVertexAttrib1f((UInt32)index, (Single)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib1fv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fv(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1fv(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fv(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1fv(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1s(UInt32 index, Int16 x)
        {
            Delegates.glVertexAttrib1s((UInt32)index, (Int16)x);
        }

        public static 
        void glVertexAttrib1s(Int32 index, Int16 x)
        {
            Delegates.glVertexAttrib1s((UInt32)index, (Int16)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1sv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib1sv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1sv(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1sv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1sv(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1sv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2d(UInt32 index, Double x, Double y)
        {
            Delegates.glVertexAttrib2d((UInt32)index, (Double)x, (Double)y);
        }

        public static 
        void glVertexAttrib2d(Int32 index, Double x, Double y)
        {
            Delegates.glVertexAttrib2d((UInt32)index, (Double)x, (Double)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib2dv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dv(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2dv(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dv(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2dv(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2f(UInt32 index, Single x, Single y)
        {
            Delegates.glVertexAttrib2f((UInt32)index, (Single)x, (Single)y);
        }

        public static 
        void glVertexAttrib2f(Int32 index, Single x, Single y)
        {
            Delegates.glVertexAttrib2f((UInt32)index, (Single)x, (Single)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib2fv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fv(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2fv(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fv(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2fv(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2s(UInt32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2s((UInt32)index, (Int16)x, (Int16)y);
        }

        public static 
        void glVertexAttrib2s(Int32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2s((UInt32)index, (Int16)x, (Int16)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2sv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib2sv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2sv(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2sv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2sv(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2sv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3d(UInt32 index, Double x, Double y, Double z)
        {
            Delegates.glVertexAttrib3d((UInt32)index, (Double)x, (Double)y, (Double)z);
        }

        public static 
        void glVertexAttrib3d(Int32 index, Double x, Double y, Double z)
        {
            Delegates.glVertexAttrib3d((UInt32)index, (Double)x, (Double)y, (Double)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib3dv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dv(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3dv(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dv(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3dv(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3f(UInt32 index, Single x, Single y, Single z)
        {
            Delegates.glVertexAttrib3f((UInt32)index, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glVertexAttrib3f(Int32 index, Single x, Single y, Single z)
        {
            Delegates.glVertexAttrib3f((UInt32)index, (Single)x, (Single)y, (Single)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib3fv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fv(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3fv(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fv(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3fv(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3s(UInt32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3s((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glVertexAttrib3s(Int32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3s((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3sv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib3sv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3sv(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3sv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3sv(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3sv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nbv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v);
            }
        }

        public static 
        void glVertexAttrib4Nbv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nbv(UInt32 index, SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nbv(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nbv(UInt32 index, ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nbv(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Niv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v);
            }
        }

        public static 
        void glVertexAttrib4Niv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Niv(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Niv(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Niv(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Niv(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nsv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib4Nsv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nsv(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nsv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nsv(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nsv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nub(UInt32 index, Byte x, Byte y, Byte z, Byte w)
        {
            Delegates.glVertexAttrib4Nub((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
        }

        public static 
        void glVertexAttrib4Nub(Int32 index, Byte x, Byte y, Byte z, Byte w)
        {
            Delegates.glVertexAttrib4Nub((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nubv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v);
            }
        }

        public static 
        void glVertexAttrib4Nubv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nubv(UInt32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nubv(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nubv(UInt32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nubv(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nuiv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v);
            }
        }

        public static 
        void glVertexAttrib4Nuiv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nuiv(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nuiv(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nuiv(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nuiv(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nusv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttrib4Nusv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nusv(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nusv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4Nusv(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4Nusv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4bv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v);
            }
        }

        public static 
        void glVertexAttrib4bv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4bv(UInt32 index, SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4bv(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4bv(UInt32 index, ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4bv(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4d(UInt32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexAttrib4d((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glVertexAttrib4d(Int32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexAttrib4d((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib4dv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dv(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4dv(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dv(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4dv(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4f(UInt32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexAttrib4f((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glVertexAttrib4f(Int32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexAttrib4f((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib4fv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fv(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4fv(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fv(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4fv(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4iv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v);
            }
        }

        public static 
        void glVertexAttrib4iv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4iv(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4iv(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4iv(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4iv(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4s(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4s((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void glVertexAttrib4s(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4s((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4sv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib4sv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4sv(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4sv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4sv(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4sv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v);
            }
        }

        public static 
        void glVertexAttrib4ubv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubv(UInt32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4ubv(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubv(UInt32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4ubv(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4uiv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v);
            }
        }

        public static 
        void glVertexAttrib4uiv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4uiv(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4uiv(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4uiv(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4uiv(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4usv(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttrib4usv(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4usv(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4usv(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4usv(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4usv(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribPointer(UInt32 index, Int32 size, int type, Int32 normalized, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexAttribPointer(Int32 index, Int32 size, int type, Int32 normalized, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (IntPtr)pointer);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribPointer(UInt32 index, Int32 size, int type, Int32 normalized, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexAttribPointer(Int32 index, Int32 size, int type, Int32 normalized, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glUniformMatrix2x3fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix2x3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix2x3fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix2x3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix2x3fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix2x3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix3x2fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix3x2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix3x2fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix3x2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix3x2fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix3x2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix2x4fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix2x4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix2x4fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix2x4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix2x4fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix2x4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix4x2fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix4x2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix4x2fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix4x2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix4x2fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix4x2fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix3x4fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix3x4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix3x4fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix3x4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix3x4fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix3x4fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix4x3fv(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix4x3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix4x3fv(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix4x3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix4x3fv(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix4x3fv((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glActiveTextureARB(int texture)
        {
            Delegates.glActiveTextureARB((int)texture);
        }

        public static 
        void glClientActiveTextureARB(int texture)
        {
            Delegates.glClientActiveTextureARB((int)texture);
        }

        public static 
        void glMultiTexCoord1dARB(int target, Double s)
        {
            Delegates.glMultiTexCoord1dARB((int)target, (Double)s);
        }

        public static 
        void glMultiTexCoord1dvARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1dvARB((int)target, (Double*)v);
            }
        }

        public static 
        void glMultiTexCoord1dvARB(int target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1dvARB((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1dvARB(int target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1dvARB((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1fARB(int target, Single s)
        {
            Delegates.glMultiTexCoord1fARB((int)target, (Single)s);
        }

        public static 
        void glMultiTexCoord1fvARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1fvARB((int)target, (Single*)v);
            }
        }

        public static 
        void glMultiTexCoord1fvARB(int target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1fvARB((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1fvARB(int target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1fvARB((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1iARB(int target, Int32 s)
        {
            Delegates.glMultiTexCoord1iARB((int)target, (Int32)s);
        }

        public static 
        void glMultiTexCoord1ivARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1ivARB((int)target, (Int32*)v);
            }
        }

        public static 
        void glMultiTexCoord1ivARB(int target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1ivARB((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1ivARB(int target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1ivARB((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1sARB(int target, Int16 s)
        {
            Delegates.glMultiTexCoord1sARB((int)target, (Int16)s);
        }

        public static 
        void glMultiTexCoord1svARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1svARB((int)target, (Int16*)v);
            }
        }

        public static 
        void glMultiTexCoord1svARB(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1svARB((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1svARB(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1svARB((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2dARB(int target, Double s, Double t)
        {
            Delegates.glMultiTexCoord2dARB((int)target, (Double)s, (Double)t);
        }

        public static 
        void glMultiTexCoord2dvARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2dvARB((int)target, (Double*)v);
            }
        }

        public static 
        void glMultiTexCoord2dvARB(int target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2dvARB((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2dvARB(int target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2dvARB((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2fARB(int target, Single s, Single t)
        {
            Delegates.glMultiTexCoord2fARB((int)target, (Single)s, (Single)t);
        }

        public static 
        void glMultiTexCoord2fvARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2fvARB((int)target, (Single*)v);
            }
        }

        public static 
        void glMultiTexCoord2fvARB(int target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2fvARB((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2fvARB(int target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2fvARB((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2iARB(int target, Int32 s, Int32 t)
        {
            Delegates.glMultiTexCoord2iARB((int)target, (Int32)s, (Int32)t);
        }

        public static 
        void glMultiTexCoord2ivARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2ivARB((int)target, (Int32*)v);
            }
        }

        public static 
        void glMultiTexCoord2ivARB(int target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2ivARB((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2ivARB(int target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2ivARB((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2sARB(int target, Int16 s, Int16 t)
        {
            Delegates.glMultiTexCoord2sARB((int)target, (Int16)s, (Int16)t);
        }

        public static 
        void glMultiTexCoord2svARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2svARB((int)target, (Int16*)v);
            }
        }

        public static 
        void glMultiTexCoord2svARB(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2svARB((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2svARB(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2svARB((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3dARB(int target, Double s, Double t, Double r)
        {
            Delegates.glMultiTexCoord3dARB((int)target, (Double)s, (Double)t, (Double)r);
        }

        public static 
        void glMultiTexCoord3dvARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3dvARB((int)target, (Double*)v);
            }
        }

        public static 
        void glMultiTexCoord3dvARB(int target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3dvARB((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3dvARB(int target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3dvARB((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3fARB(int target, Single s, Single t, Single r)
        {
            Delegates.glMultiTexCoord3fARB((int)target, (Single)s, (Single)t, (Single)r);
        }

        public static 
        void glMultiTexCoord3fvARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3fvARB((int)target, (Single*)v);
            }
        }

        public static 
        void glMultiTexCoord3fvARB(int target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3fvARB((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3fvARB(int target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3fvARB((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3iARB(int target, Int32 s, Int32 t, Int32 r)
        {
            Delegates.glMultiTexCoord3iARB((int)target, (Int32)s, (Int32)t, (Int32)r);
        }

        public static 
        void glMultiTexCoord3ivARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3ivARB((int)target, (Int32*)v);
            }
        }

        public static 
        void glMultiTexCoord3ivARB(int target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3ivARB((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3ivARB(int target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3ivARB((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3sARB(int target, Int16 s, Int16 t, Int16 r)
        {
            Delegates.glMultiTexCoord3sARB((int)target, (Int16)s, (Int16)t, (Int16)r);
        }

        public static 
        void glMultiTexCoord3svARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3svARB((int)target, (Int16*)v);
            }
        }

        public static 
        void glMultiTexCoord3svARB(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3svARB((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3svARB(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3svARB((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4dARB(int target, Double s, Double t, Double r, Double q)
        {
            Delegates.glMultiTexCoord4dARB((int)target, (Double)s, (Double)t, (Double)r, (Double)q);
        }

        public static 
        void glMultiTexCoord4dvARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4dvARB((int)target, (Double*)v);
            }
        }

        public static 
        void glMultiTexCoord4dvARB(int target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4dvARB((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4dvARB(int target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4dvARB((int)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4fARB(int target, Single s, Single t, Single r, Single q)
        {
            Delegates.glMultiTexCoord4fARB((int)target, (Single)s, (Single)t, (Single)r, (Single)q);
        }

        public static 
        void glMultiTexCoord4fvARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4fvARB((int)target, (Single*)v);
            }
        }

        public static 
        void glMultiTexCoord4fvARB(int target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4fvARB((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4fvARB(int target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4fvARB((int)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4iARB(int target, Int32 s, Int32 t, Int32 r, Int32 q)
        {
            Delegates.glMultiTexCoord4iARB((int)target, (Int32)s, (Int32)t, (Int32)r, (Int32)q);
        }

        public static 
        void glMultiTexCoord4ivARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4ivARB((int)target, (Int32*)v);
            }
        }

        public static 
        void glMultiTexCoord4ivARB(int target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4ivARB((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4ivARB(int target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4ivARB((int)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4sARB(int target, Int16 s, Int16 t, Int16 r, Int16 q)
        {
            Delegates.glMultiTexCoord4sARB((int)target, (Int16)s, (Int16)t, (Int16)r, (Int16)q);
        }

        public static 
        void glMultiTexCoord4svARB(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4svARB((int)target, (Int16*)v);
            }
        }

        public static 
        void glMultiTexCoord4svARB(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4svARB((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4svARB(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4svARB((int)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glLoadTransposeMatrixfARB(IntPtr m)
        {
            unsafe
            {
                Delegates.glLoadTransposeMatrixfARB((Single*)m);
            }
        }

        public static 
        void glLoadTransposeMatrixfARB(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glLoadTransposeMatrixfARB((Single*)m_ptr);
                }
            }
        }

        public static 
        void glLoadTransposeMatrixfARB(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glLoadTransposeMatrixfARB((Single*)m_ptr);
                }
            }
        }

        public static 
        void glLoadTransposeMatrixdARB(IntPtr m)
        {
            unsafe
            {
                Delegates.glLoadTransposeMatrixdARB((Double*)m);
            }
        }

        public static 
        void glLoadTransposeMatrixdARB(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glLoadTransposeMatrixdARB((Double*)m_ptr);
                }
            }
        }

        public static 
        void glLoadTransposeMatrixdARB(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glLoadTransposeMatrixdARB((Double*)m_ptr);
                }
            }
        }

        public static 
        void glMultTransposeMatrixfARB(IntPtr m)
        {
            unsafe
            {
                Delegates.glMultTransposeMatrixfARB((Single*)m);
            }
        }

        public static 
        void glMultTransposeMatrixfARB(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glMultTransposeMatrixfARB((Single*)m_ptr);
                }
            }
        }

        public static 
        void glMultTransposeMatrixfARB(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glMultTransposeMatrixfARB((Single*)m_ptr);
                }
            }
        }

        public static 
        void glMultTransposeMatrixdARB(IntPtr m)
        {
            unsafe
            {
                Delegates.glMultTransposeMatrixdARB((Double*)m);
            }
        }

        public static 
        void glMultTransposeMatrixdARB(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glMultTransposeMatrixdARB((Double*)m_ptr);
                }
            }
        }

        public static 
        void glMultTransposeMatrixdARB(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glMultTransposeMatrixdARB((Double*)m_ptr);
                }
            }
        }

        public static 
        void glSampleCoverageARB(Single value, Int32 invert)
        {
            Delegates.glSampleCoverageARB((Single)value, (Int32)invert);
        }

        public static 
        void glCompressedTexImage3DARB(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexImage3DARB((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexImage3DARB(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage3DARB((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexImage2DARB(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexImage2DARB((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexImage2DARB(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage2DARB((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexImage1DARB(int target, Int32 level, int internalformat, Int32 width, Int32 border, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexImage1DARB((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexImage1DARB(int target, Int32 level, int internalformat, Int32 width, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage1DARB((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexSubImage3DARB(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, int format, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexSubImage3DARB((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (int)format, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexSubImage3DARB(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, int format, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage3DARB((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (int)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexSubImage2DARB(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, int format, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexSubImage2DARB((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (int)format, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexSubImage2DARB(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, int format, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage2DARB((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (int)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCompressedTexSubImage1DARB(int target, Int32 level, Int32 xoffset, Int32 width, int format, Int32 imageSize, IntPtr data)
        {
            unsafe
            {
                Delegates.glCompressedTexSubImage1DARB((int)target, (Int32)level, (Int32)xoffset, (Int32)width, (int)format, (Int32)imageSize, (IntPtr)data);
            }
        }

        public static 
        void glCompressedTexSubImage1DARB(int target, Int32 level, Int32 xoffset, Int32 width, int format, Int32 imageSize, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage1DARB((int)target, (Int32)level, (Int32)xoffset, (Int32)width, (int)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glGetCompressedTexImageARB(int target, Int32 level, [Out] IntPtr img)
        {
            unsafe
            {
                Delegates.glGetCompressedTexImageARB((int)target, (Int32)level, (IntPtr)img);
            }
        }

        public static 
        void glGetCompressedTexImageARB(int target, Int32 level, [In, Out] object img)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle img_ptr = System.Runtime.InteropServices.GCHandle.Alloc(img, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetCompressedTexImageARB((int)target, (Int32)level, (IntPtr)img_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    img_ptr.Free();
                }
            }
        }

        public static 
        void glPointParameterfARB(int pname, Single param)
        {
            Delegates.glPointParameterfARB((int)pname, (Single)param);
        }

        public static 
        void glPointParameterfvARB(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPointParameterfvARB((int)pname, (Single*)@params);
            }
        }

        public static 
        void glPointParameterfvARB(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glPointParameterfvARB((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glPointParameterfvARB(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glPointParameterfvARB((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glWeightbvARB(Int32 size, IntPtr weights)
        {
            unsafe
            {
                Delegates.glWeightbvARB((Int32)size, (SByte*)weights);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glWeightbvARB(Int32 size, SByte[] weights)
        {
            unsafe
            {
                fixed (SByte* weights_ptr = weights)
                {
                    Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightbvARB(Int32 size, Byte[] weights)
        {
            unsafe
            {
                fixed (Byte* weights_ptr = weights)
                {
                    Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glWeightbvARB(Int32 size, ref SByte weights)
        {
            unsafe
            {
                fixed (SByte* weights_ptr = &weights)
                {
                    Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightbvARB(Int32 size, ref Byte weights)
        {
            unsafe
            {
                fixed (Byte* weights_ptr = &weights)
                {
                    Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightsvARB(Int32 size, IntPtr weights)
        {
            unsafe
            {
                Delegates.glWeightsvARB((Int32)size, (Int16*)weights);
            }
        }

        public static 
        void glWeightsvARB(Int32 size, Int16[] weights)
        {
            unsafe
            {
                fixed (Int16* weights_ptr = weights)
                {
                    Delegates.glWeightsvARB((Int32)size, (Int16*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightsvARB(Int32 size, ref Int16 weights)
        {
            unsafe
            {
                fixed (Int16* weights_ptr = &weights)
                {
                    Delegates.glWeightsvARB((Int32)size, (Int16*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightivARB(Int32 size, IntPtr weights)
        {
            unsafe
            {
                Delegates.glWeightivARB((Int32)size, (Int32*)weights);
            }
        }

        public static 
        void glWeightivARB(Int32 size, Int32[] weights)
        {
            unsafe
            {
                fixed (Int32* weights_ptr = weights)
                {
                    Delegates.glWeightivARB((Int32)size, (Int32*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightivARB(Int32 size, ref Int32 weights)
        {
            unsafe
            {
                fixed (Int32* weights_ptr = &weights)
                {
                    Delegates.glWeightivARB((Int32)size, (Int32*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightfvARB(Int32 size, IntPtr weights)
        {
            unsafe
            {
                Delegates.glWeightfvARB((Int32)size, (Single*)weights);
            }
        }

        public static 
        void glWeightfvARB(Int32 size, Single[] weights)
        {
            unsafe
            {
                fixed (Single* weights_ptr = weights)
                {
                    Delegates.glWeightfvARB((Int32)size, (Single*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightfvARB(Int32 size, ref Single weights)
        {
            unsafe
            {
                fixed (Single* weights_ptr = &weights)
                {
                    Delegates.glWeightfvARB((Int32)size, (Single*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightdvARB(Int32 size, IntPtr weights)
        {
            unsafe
            {
                Delegates.glWeightdvARB((Int32)size, (Double*)weights);
            }
        }

        public static 
        void glWeightdvARB(Int32 size, Double[] weights)
        {
            unsafe
            {
                fixed (Double* weights_ptr = weights)
                {
                    Delegates.glWeightdvARB((Int32)size, (Double*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightdvARB(Int32 size, ref Double weights)
        {
            unsafe
            {
                fixed (Double* weights_ptr = &weights)
                {
                    Delegates.glWeightdvARB((Int32)size, (Double*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightubvARB(Int32 size, IntPtr weights)
        {
            unsafe
            {
                Delegates.glWeightubvARB((Int32)size, (Byte*)weights);
            }
        }

        public static 
        void glWeightubvARB(Int32 size, Byte[] weights)
        {
            unsafe
            {
                fixed (Byte* weights_ptr = weights)
                {
                    Delegates.glWeightubvARB((Int32)size, (Byte*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightubvARB(Int32 size, ref Byte weights)
        {
            unsafe
            {
                fixed (Byte* weights_ptr = &weights)
                {
                    Delegates.glWeightubvARB((Int32)size, (Byte*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightusvARB(Int32 size, IntPtr weights)
        {
            unsafe
            {
                Delegates.glWeightusvARB((Int32)size, (UInt16*)weights);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glWeightusvARB(Int32 size, UInt16[] weights)
        {
            unsafe
            {
                fixed (UInt16* weights_ptr = weights)
                {
                    Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightusvARB(Int32 size, Int16[] weights)
        {
            unsafe
            {
                fixed (Int16* weights_ptr = weights)
                {
                    Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glWeightusvARB(Int32 size, ref UInt16 weights)
        {
            unsafe
            {
                fixed (UInt16* weights_ptr = &weights)
                {
                    Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightusvARB(Int32 size, ref Int16 weights)
        {
            unsafe
            {
                fixed (Int16* weights_ptr = &weights)
                {
                    Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightuivARB(Int32 size, IntPtr weights)
        {
            unsafe
            {
                Delegates.glWeightuivARB((Int32)size, (UInt32*)weights);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glWeightuivARB(Int32 size, UInt32[] weights)
        {
            unsafe
            {
                fixed (UInt32* weights_ptr = weights)
                {
                    Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightuivARB(Int32 size, Int32[] weights)
        {
            unsafe
            {
                fixed (Int32* weights_ptr = weights)
                {
                    Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glWeightuivARB(Int32 size, ref UInt32 weights)
        {
            unsafe
            {
                fixed (UInt32* weights_ptr = &weights)
                {
                    Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightuivARB(Int32 size, ref Int32 weights)
        {
            unsafe
            {
                fixed (Int32* weights_ptr = &weights)
                {
                    Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
                }
            }
        }

        public static 
        void glWeightPointerARB(Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glWeightPointerARB((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glWeightPointerARB(Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glWeightPointerARB((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexBlendARB(Int32 count)
        {
            Delegates.glVertexBlendARB((Int32)count);
        }

        public static 
        void glCurrentPaletteMatrixARB(Int32 index)
        {
            Delegates.glCurrentPaletteMatrixARB((Int32)index);
        }

        public static 
        void glMatrixIndexubvARB(Int32 size, IntPtr indices)
        {
            unsafe
            {
                Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices);
            }
        }

        public static 
        void glMatrixIndexubvARB(Int32 size, Byte[] indices)
        {
            unsafe
            {
                fixed (Byte* indices_ptr = indices)
                {
                    Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices_ptr);
                }
            }
        }

        public static 
        void glMatrixIndexubvARB(Int32 size, ref Byte indices)
        {
            unsafe
            {
                fixed (Byte* indices_ptr = &indices)
                {
                    Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices_ptr);
                }
            }
        }

        public static 
        void glMatrixIndexusvARB(Int32 size, IntPtr indices)
        {
            unsafe
            {
                Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMatrixIndexusvARB(Int32 size, UInt16[] indices)
        {
            unsafe
            {
                fixed (UInt16* indices_ptr = indices)
                {
                    Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
                }
            }
        }

        public static 
        void glMatrixIndexusvARB(Int32 size, Int16[] indices)
        {
            unsafe
            {
                fixed (Int16* indices_ptr = indices)
                {
                    Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMatrixIndexusvARB(Int32 size, ref UInt16 indices)
        {
            unsafe
            {
                fixed (UInt16* indices_ptr = &indices)
                {
                    Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
                }
            }
        }

        public static 
        void glMatrixIndexusvARB(Int32 size, ref Int16 indices)
        {
            unsafe
            {
                fixed (Int16* indices_ptr = &indices)
                {
                    Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
                }
            }
        }

        public static 
        void glMatrixIndexuivARB(Int32 size, IntPtr indices)
        {
            unsafe
            {
                Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMatrixIndexuivARB(Int32 size, UInt32[] indices)
        {
            unsafe
            {
                fixed (UInt32* indices_ptr = indices)
                {
                    Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
                }
            }
        }

        public static 
        void glMatrixIndexuivARB(Int32 size, Int32[] indices)
        {
            unsafe
            {
                fixed (Int32* indices_ptr = indices)
                {
                    Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMatrixIndexuivARB(Int32 size, ref UInt32 indices)
        {
            unsafe
            {
                fixed (UInt32* indices_ptr = &indices)
                {
                    Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
                }
            }
        }

        public static 
        void glMatrixIndexuivARB(Int32 size, ref Int32 indices)
        {
            unsafe
            {
                fixed (Int32* indices_ptr = &indices)
                {
                    Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
                }
            }
        }

        public static 
        void glMatrixIndexPointerARB(Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glMatrixIndexPointerARB((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glMatrixIndexPointerARB(Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMatrixIndexPointerARB((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glWindowPos2dARB(Double x, Double y)
        {
            Delegates.glWindowPos2dARB((Double)x, (Double)y);
        }

        public static 
        void glWindowPos2dvARB(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2dvARB((Double*)v);
            }
        }

        public static 
        void glWindowPos2dvARB(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos2dvARB((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2dvARB(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos2dvARB((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2fARB(Single x, Single y)
        {
            Delegates.glWindowPos2fARB((Single)x, (Single)y);
        }

        public static 
        void glWindowPos2fvARB(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2fvARB((Single*)v);
            }
        }

        public static 
        void glWindowPos2fvARB(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos2fvARB((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2fvARB(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos2fvARB((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2iARB(Int32 x, Int32 y)
        {
            Delegates.glWindowPos2iARB((Int32)x, (Int32)y);
        }

        public static 
        void glWindowPos2ivARB(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2ivARB((Int32*)v);
            }
        }

        public static 
        void glWindowPos2ivARB(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos2ivARB((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2ivARB(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos2ivARB((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2sARB(Int16 x, Int16 y)
        {
            Delegates.glWindowPos2sARB((Int16)x, (Int16)y);
        }

        public static 
        void glWindowPos2svARB(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2svARB((Int16*)v);
            }
        }

        public static 
        void glWindowPos2svARB(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos2svARB((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2svARB(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos2svARB((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3dARB(Double x, Double y, Double z)
        {
            Delegates.glWindowPos3dARB((Double)x, (Double)y, (Double)z);
        }

        public static 
        void glWindowPos3dvARB(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3dvARB((Double*)v);
            }
        }

        public static 
        void glWindowPos3dvARB(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos3dvARB((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3dvARB(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos3dvARB((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3fARB(Single x, Single y, Single z)
        {
            Delegates.glWindowPos3fARB((Single)x, (Single)y, (Single)z);
        }

        public static 
        void glWindowPos3fvARB(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3fvARB((Single*)v);
            }
        }

        public static 
        void glWindowPos3fvARB(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos3fvARB((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3fvARB(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos3fvARB((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3iARB(Int32 x, Int32 y, Int32 z)
        {
            Delegates.glWindowPos3iARB((Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void glWindowPos3ivARB(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3ivARB((Int32*)v);
            }
        }

        public static 
        void glWindowPos3ivARB(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos3ivARB((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3ivARB(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos3ivARB((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3sARB(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glWindowPos3sARB((Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glWindowPos3svARB(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3svARB((Int16*)v);
            }
        }

        public static 
        void glWindowPos3svARB(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos3svARB((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3svARB(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos3svARB((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dARB(UInt32 index, Double x)
        {
            Delegates.glVertexAttrib1dARB((UInt32)index, (Double)x);
        }

        public static 
        void glVertexAttrib1dARB(Int32 index, Double x)
        {
            Delegates.glVertexAttrib1dARB((UInt32)index, (Double)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib1dvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dvARB(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1dvARB(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dvARB(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1dvARB(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fARB(UInt32 index, Single x)
        {
            Delegates.glVertexAttrib1fARB((UInt32)index, (Single)x);
        }

        public static 
        void glVertexAttrib1fARB(Int32 index, Single x)
        {
            Delegates.glVertexAttrib1fARB((UInt32)index, (Single)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib1fvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fvARB(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1fvARB(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fvARB(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1fvARB(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1sARB(UInt32 index, Int16 x)
        {
            Delegates.glVertexAttrib1sARB((UInt32)index, (Int16)x);
        }

        public static 
        void glVertexAttrib1sARB(Int32 index, Int16 x)
        {
            Delegates.glVertexAttrib1sARB((UInt32)index, (Int16)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1svARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib1svARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1svARB(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1svARB(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1svARB(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1svARB(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dARB(UInt32 index, Double x, Double y)
        {
            Delegates.glVertexAttrib2dARB((UInt32)index, (Double)x, (Double)y);
        }

        public static 
        void glVertexAttrib2dARB(Int32 index, Double x, Double y)
        {
            Delegates.glVertexAttrib2dARB((UInt32)index, (Double)x, (Double)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib2dvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dvARB(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2dvARB(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dvARB(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2dvARB(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fARB(UInt32 index, Single x, Single y)
        {
            Delegates.glVertexAttrib2fARB((UInt32)index, (Single)x, (Single)y);
        }

        public static 
        void glVertexAttrib2fARB(Int32 index, Single x, Single y)
        {
            Delegates.glVertexAttrib2fARB((UInt32)index, (Single)x, (Single)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib2fvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fvARB(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2fvARB(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fvARB(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2fvARB(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2sARB(UInt32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2sARB((UInt32)index, (Int16)x, (Int16)y);
        }

        public static 
        void glVertexAttrib2sARB(Int32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2sARB((UInt32)index, (Int16)x, (Int16)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2svARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib2svARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2svARB(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2svARB(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2svARB(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2svARB(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dARB(UInt32 index, Double x, Double y, Double z)
        {
            Delegates.glVertexAttrib3dARB((UInt32)index, (Double)x, (Double)y, (Double)z);
        }

        public static 
        void glVertexAttrib3dARB(Int32 index, Double x, Double y, Double z)
        {
            Delegates.glVertexAttrib3dARB((UInt32)index, (Double)x, (Double)y, (Double)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib3dvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dvARB(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3dvARB(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dvARB(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3dvARB(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fARB(UInt32 index, Single x, Single y, Single z)
        {
            Delegates.glVertexAttrib3fARB((UInt32)index, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glVertexAttrib3fARB(Int32 index, Single x, Single y, Single z)
        {
            Delegates.glVertexAttrib3fARB((UInt32)index, (Single)x, (Single)y, (Single)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib3fvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fvARB(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3fvARB(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fvARB(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3fvARB(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3sARB(UInt32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glVertexAttrib3sARB(Int32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3svARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib3svARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3svARB(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3svARB(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3svARB(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3svARB(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NbvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v);
            }
        }

        public static 
        void glVertexAttrib4NbvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NbvARB(UInt32 index, SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NbvARB(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NbvARB(UInt32 index, ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NbvARB(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NivARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v);
            }
        }

        public static 
        void glVertexAttrib4NivARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NivARB(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NivARB(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NivARB(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NivARB(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NsvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib4NsvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NsvARB(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NsvARB(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NsvARB(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NsvARB(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NubARB(UInt32 index, Byte x, Byte y, Byte z, Byte w)
        {
            Delegates.glVertexAttrib4NubARB((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
        }

        public static 
        void glVertexAttrib4NubARB(Int32 index, Byte x, Byte y, Byte z, Byte w)
        {
            Delegates.glVertexAttrib4NubARB((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NubvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v);
            }
        }

        public static 
        void glVertexAttrib4NubvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NubvARB(UInt32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NubvARB(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NubvARB(UInt32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NubvARB(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NuivARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v);
            }
        }

        public static 
        void glVertexAttrib4NuivARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NuivARB(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NuivARB(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NuivARB(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NuivARB(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NusvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttrib4NusvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NusvARB(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NusvARB(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4NusvARB(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4NusvARB(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4bvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v);
            }
        }

        public static 
        void glVertexAttrib4bvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4bvARB(UInt32 index, SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4bvARB(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4bvARB(UInt32 index, ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4bvARB(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dARB(UInt32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexAttrib4dARB((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glVertexAttrib4dARB(Int32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexAttrib4dARB((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib4dvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dvARB(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4dvARB(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dvARB(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4dvARB(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fARB(UInt32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexAttrib4fARB((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glVertexAttrib4fARB(Int32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexAttrib4fARB((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib4fvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fvARB(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4fvARB(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fvARB(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4fvARB(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ivARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v);
            }
        }

        public static 
        void glVertexAttrib4ivARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ivARB(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4ivARB(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ivARB(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4ivARB(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4sARB(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void glVertexAttrib4sARB(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4svARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib4svARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4svARB(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4svARB(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4svARB(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4svARB(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v);
            }
        }

        public static 
        void glVertexAttrib4ubvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubvARB(UInt32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4ubvARB(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubvARB(UInt32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4ubvARB(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4uivARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v);
            }
        }

        public static 
        void glVertexAttrib4uivARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4uivARB(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4uivARB(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4uivARB(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4uivARB(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4usvARB(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttrib4usvARB(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4usvARB(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4usvARB(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4usvARB(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4usvARB(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribPointerARB(UInt32 index, Int32 size, int type, Int32 normalized, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexAttribPointerARB(Int32 index, Int32 size, int type, Int32 normalized, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (IntPtr)pointer);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribPointerARB(UInt32 index, Int32 size, int type, Int32 normalized, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexAttribPointerARB(Int32 index, Int32 size, int type, Int32 normalized, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glEnableVertexAttribArrayARB(UInt32 index)
        {
            Delegates.glEnableVertexAttribArrayARB((UInt32)index);
        }

        public static 
        void glEnableVertexAttribArrayARB(Int32 index)
        {
            Delegates.glEnableVertexAttribArrayARB((UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDisableVertexAttribArrayARB(UInt32 index)
        {
            Delegates.glDisableVertexAttribArrayARB((UInt32)index);
        }

        public static 
        void glDisableVertexAttribArrayARB(Int32 index)
        {
            Delegates.glDisableVertexAttribArrayARB((UInt32)index);
        }

        public static 
        void glProgramStringARB(int target, int format, Int32 len, IntPtr @string)
        {
            unsafe
            {
                Delegates.glProgramStringARB((int)target, (int)format, (Int32)len, (IntPtr)@string);
            }
        }

        public static 
        void glProgramStringARB(int target, int format, Int32 len, [In, Out] object @string)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glProgramStringARB((int)target, (int)format, (Int32)len, (IntPtr)@string_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @string_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindProgramARB(int target, UInt32 program)
        {
            Delegates.glBindProgramARB((int)target, (UInt32)program);
        }

        public static 
        void glBindProgramARB(int target, Int32 program)
        {
            Delegates.glBindProgramARB((int)target, (UInt32)program);
        }

        public static 
        void glDeleteProgramsARB(Int32 n, IntPtr programs)
        {
            unsafe
            {
                Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteProgramsARB(Int32 n, UInt32[] programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = programs)
                {
                    Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glDeleteProgramsARB(Int32 n, Int32[] programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = programs)
                {
                    Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteProgramsARB(Int32 n, ref UInt32 programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = &programs)
                {
                    Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glDeleteProgramsARB(Int32 n, ref Int32 programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = &programs)
                {
                    Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glGenProgramsARB(Int32 n, [Out] IntPtr programs)
        {
            unsafe
            {
                Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenProgramsARB(Int32 n, [Out] UInt32[] programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = programs)
                {
                    Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glGenProgramsARB(Int32 n, [Out] Int32[] programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = programs)
                {
                    Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenProgramsARB(Int32 n, [Out] out UInt32 programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = &programs)
                {
                    Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
                    programs = *programs_ptr;
                }
            }
        }

        public static 
        void glGenProgramsARB(Int32 n, [Out] out Int32 programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = &programs)
                {
                    Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
                    programs = *programs_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameter4dARB(int target, UInt32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glProgramEnvParameter4dARB((int)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glProgramEnvParameter4dARB(int target, Int32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glProgramEnvParameter4dARB((int)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameter4dvARB(int target, UInt32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameter4dvARB((int)target, (UInt32)index, (Double*)@params);
            }
        }

        public static 
        void glProgramEnvParameter4dvARB(int target, Int32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameter4dvARB((int)target, (UInt32)index, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameter4dvARB(int target, UInt32 index, Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameter4dvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameter4dvARB(int target, Int32 index, Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameter4dvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameter4dvARB(int target, UInt32 index, ref Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameter4dvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameter4dvARB(int target, Int32 index, ref Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameter4dvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameter4fARB(int target, UInt32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glProgramEnvParameter4fARB((int)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glProgramEnvParameter4fARB(int target, Int32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glProgramEnvParameter4fARB((int)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameter4fvARB(int target, UInt32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameter4fvARB((int)target, (UInt32)index, (Single*)@params);
            }
        }

        public static 
        void glProgramEnvParameter4fvARB(int target, Int32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameter4fvARB((int)target, (UInt32)index, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameter4fvARB(int target, UInt32 index, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameter4fvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameter4fvARB(int target, Int32 index, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameter4fvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameter4fvARB(int target, UInt32 index, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameter4fvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameter4fvARB(int target, Int32 index, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameter4fvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameter4dARB(int target, UInt32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glProgramLocalParameter4dARB((int)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glProgramLocalParameter4dARB(int target, Int32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glProgramLocalParameter4dARB((int)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameter4dvARB(int target, UInt32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameter4dvARB((int)target, (UInt32)index, (Double*)@params);
            }
        }

        public static 
        void glProgramLocalParameter4dvARB(int target, Int32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameter4dvARB((int)target, (UInt32)index, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameter4dvARB(int target, UInt32 index, Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameter4dvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameter4dvARB(int target, Int32 index, Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameter4dvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameter4dvARB(int target, UInt32 index, ref Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameter4dvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameter4dvARB(int target, Int32 index, ref Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameter4dvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameter4fARB(int target, UInt32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glProgramLocalParameter4fARB((int)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glProgramLocalParameter4fARB(int target, Int32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glProgramLocalParameter4fARB((int)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameter4fvARB(int target, UInt32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameter4fvARB((int)target, (UInt32)index, (Single*)@params);
            }
        }

        public static 
        void glProgramLocalParameter4fvARB(int target, Int32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameter4fvARB((int)target, (UInt32)index, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameter4fvARB(int target, UInt32 index, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameter4fvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameter4fvARB(int target, Int32 index, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameter4fvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameter4fvARB(int target, UInt32 index, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameter4fvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameter4fvARB(int target, Int32 index, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameter4fvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterdvARB(int target, UInt32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramEnvParameterdvARB((int)target, (UInt32)index, (Double*)@params);
            }
        }

        public static 
        void glGetProgramEnvParameterdvARB(int target, Int32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramEnvParameterdvARB((int)target, (UInt32)index, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterdvARB(int target, UInt32 index, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramEnvParameterdvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramEnvParameterdvARB(int target, Int32 index, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramEnvParameterdvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterdvARB(int target, UInt32 index, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramEnvParameterdvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramEnvParameterdvARB(int target, Int32 index, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramEnvParameterdvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterfvARB(int target, UInt32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramEnvParameterfvARB((int)target, (UInt32)index, (Single*)@params);
            }
        }

        public static 
        void glGetProgramEnvParameterfvARB(int target, Int32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramEnvParameterfvARB((int)target, (UInt32)index, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterfvARB(int target, UInt32 index, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramEnvParameterfvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramEnvParameterfvARB(int target, Int32 index, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramEnvParameterfvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterfvARB(int target, UInt32 index, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramEnvParameterfvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramEnvParameterfvARB(int target, Int32 index, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramEnvParameterfvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterdvARB(int target, UInt32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramLocalParameterdvARB((int)target, (UInt32)index, (Double*)@params);
            }
        }

        public static 
        void glGetProgramLocalParameterdvARB(int target, Int32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramLocalParameterdvARB((int)target, (UInt32)index, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterdvARB(int target, UInt32 index, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramLocalParameterdvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramLocalParameterdvARB(int target, Int32 index, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramLocalParameterdvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterdvARB(int target, UInt32 index, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramLocalParameterdvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramLocalParameterdvARB(int target, Int32 index, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramLocalParameterdvARB((int)target, (UInt32)index, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterfvARB(int target, UInt32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramLocalParameterfvARB((int)target, (UInt32)index, (Single*)@params);
            }
        }

        public static 
        void glGetProgramLocalParameterfvARB(int target, Int32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramLocalParameterfvARB((int)target, (UInt32)index, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterfvARB(int target, UInt32 index, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramLocalParameterfvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramLocalParameterfvARB(int target, Int32 index, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramLocalParameterfvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterfvARB(int target, UInt32 index, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramLocalParameterfvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramLocalParameterfvARB(int target, Int32 index, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramLocalParameterfvARB((int)target, (UInt32)index, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramivARB(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramivARB((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetProgramivARB(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramivARB((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramivARB(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramivARB((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramStringARB(int target, int pname, [Out] IntPtr @string)
        {
            unsafe
            {
                Delegates.glGetProgramStringARB((int)target, (int)pname, (IntPtr)@string);
            }
        }

        public static 
        void glGetProgramStringARB(int target, int pname, [In, Out] object @string)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetProgramStringARB((int)target, (int)pname, (IntPtr)@string_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @string_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdvARB(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribdvARB((UInt32)index, (int)pname, (Double*)@params);
            }
        }

        public static 
        void glGetVertexAttribdvARB(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribdvARB((UInt32)index, (int)pname, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdvARB(UInt32 index, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdvARB((UInt32)index, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribdvARB(Int32 index, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdvARB((UInt32)index, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdvARB(UInt32 index, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdvARB((UInt32)index, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribdvARB(Int32 index, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdvARB((UInt32)index, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfvARB(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribfvARB((UInt32)index, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetVertexAttribfvARB(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribfvARB((UInt32)index, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfvARB(UInt32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfvARB((UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribfvARB(Int32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfvARB((UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfvARB(UInt32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfvARB((UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribfvARB(Int32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfvARB((UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribivARB(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribivARB((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetVertexAttribivARB(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribivARB((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribivARB(UInt32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribivARB((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribivARB(Int32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribivARB((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribivARB(UInt32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribivARB((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribivARB(Int32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribivARB((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribPointervARB(UInt32 index, int pname, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glGetVertexAttribPointervARB((UInt32)index, (int)pname, (IntPtr)pointer);
            }
        }

        public static 
        void glGetVertexAttribPointervARB(Int32 index, int pname, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glGetVertexAttribPointervARB((UInt32)index, (int)pname, (IntPtr)pointer);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribPointervARB(UInt32 index, int pname, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointervARB((UInt32)index, (int)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glGetVertexAttribPointervARB(Int32 index, int pname, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointervARB((UInt32)index, (int)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsProgramARB(UInt32 program)
        {
            return Delegates.glIsProgramARB((UInt32)program);
        }

        public static 
        Int32 glIsProgramARB(Int32 program)
        {
            return Delegates.glIsProgramARB((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindBufferARB(int target, UInt32 buffer)
        {
            Delegates.glBindBufferARB((int)target, (UInt32)buffer);
        }

        public static 
        void glBindBufferARB(int target, Int32 buffer)
        {
            Delegates.glBindBufferARB((int)target, (UInt32)buffer);
        }

        public static 
        void glDeleteBuffersARB(Int32 n, IntPtr buffers)
        {
            unsafe
            {
                Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteBuffersARB(Int32 n, UInt32[] buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = buffers)
                {
                    Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void glDeleteBuffersARB(Int32 n, Int32[] buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteBuffersARB(Int32 n, ref UInt32 buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = &buffers)
                {
                    Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void glDeleteBuffersARB(Int32 n, ref Int32 buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void glGenBuffersARB(Int32 n, [Out] IntPtr buffers)
        {
            unsafe
            {
                Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenBuffersARB(Int32 n, [Out] UInt32[] buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = buffers)
                {
                    Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void glGenBuffersARB(Int32 n, [Out] Int32[] buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenBuffersARB(Int32 n, [Out] out UInt32 buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = &buffers)
                {
                    Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                    buffers = *buffers_ptr;
                }
            }
        }

        public static 
        void glGenBuffersARB(Int32 n, [Out] out Int32 buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                    buffers = *buffers_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsBufferARB(UInt32 buffer)
        {
            return Delegates.glIsBufferARB((UInt32)buffer);
        }

        public static 
        Int32 glIsBufferARB(Int32 buffer)
        {
            return Delegates.glIsBufferARB((UInt32)buffer);
        }

        public static 
        void glBufferDataARB(int target, IntPtr size, IntPtr data, int usage)
        {
            unsafe
            {
                Delegates.glBufferDataARB((int)target, (IntPtr)size, (IntPtr)data, (int)usage);
            }
        }

        public static 
        void glBufferDataARB(int target, IntPtr size, [In, Out] object data, int usage)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glBufferDataARB((int)target, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject(), (int)usage);
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glBufferSubDataARB(int target, IntPtr offset, IntPtr size, IntPtr data)
        {
            unsafe
            {
                Delegates.glBufferSubDataARB((int)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
            }
        }

        public static 
        void glBufferSubDataARB(int target, IntPtr offset, IntPtr size, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glBufferSubDataARB((int)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glGetBufferSubDataARB(int target, IntPtr offset, IntPtr size, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetBufferSubDataARB((int)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
            }
        }

        public static 
        void glGetBufferSubDataARB(int target, IntPtr offset, IntPtr size, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetBufferSubDataARB((int)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        IntPtr glMapBufferARB(int target, int access)
        {
            return Delegates.glMapBufferARB((int)target, (int)access);
        }

        public static 
        Int32 glUnmapBufferARB(int target)
        {
            return Delegates.glUnmapBufferARB((int)target);
        }

        public static 
        void glGetBufferParameterivARB(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetBufferParameterivARB((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetBufferParameterivARB(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetBufferParameterivARB((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetBufferParameterivARB(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetBufferParameterivARB((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetBufferPointervARB(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetBufferPointervARB((int)target, (int)pname, (IntPtr)@params);
            }
        }

        public static 
        void glGetBufferPointervARB(int target, int pname, [In, Out] object @params)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetBufferPointervARB((int)target, (int)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }
        }

        public static 
        void glGenQueriesARB(Int32 n, [Out] IntPtr ids)
        {
            unsafe
            {
                Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenQueriesARB(Int32 n, [Out] UInt32[] ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = ids)
                {
                    Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glGenQueriesARB(Int32 n, [Out] Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenQueriesARB(Int32 n, [Out] out UInt32 ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = &ids)
                {
                    Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }

        public static 
        void glGenQueriesARB(Int32 n, [Out] out Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }

        public static 
        void glDeleteQueriesARB(Int32 n, IntPtr ids)
        {
            unsafe
            {
                Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteQueriesARB(Int32 n, UInt32[] ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = ids)
                {
                    Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glDeleteQueriesARB(Int32 n, Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteQueriesARB(Int32 n, ref UInt32 ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = &ids)
                {
                    Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glDeleteQueriesARB(Int32 n, ref Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsQueryARB(UInt32 id)
        {
            return Delegates.glIsQueryARB((UInt32)id);
        }

        public static 
        Int32 glIsQueryARB(Int32 id)
        {
            return Delegates.glIsQueryARB((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBeginQueryARB(int target, UInt32 id)
        {
            Delegates.glBeginQueryARB((int)target, (UInt32)id);
        }

        public static 
        void glBeginQueryARB(int target, Int32 id)
        {
            Delegates.glBeginQueryARB((int)target, (UInt32)id);
        }

        public static 
        void glEndQueryARB(int target)
        {
            Delegates.glEndQueryARB((int)target);
        }

        public static 
        void glGetQueryivARB(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryivARB((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetQueryivARB(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryivARB((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetQueryivARB(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryivARB((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectivARB(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectivARB((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetQueryObjectivARB(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectivARB((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectivARB(UInt32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectivARB((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetQueryObjectivARB(Int32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectivARB((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectivARB(UInt32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectivARB((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetQueryObjectivARB(Int32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectivARB((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectuivARB(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectuivARB((UInt32)id, (int)pname, (UInt32*)@params);
            }
        }

        public static 
        void glGetQueryObjectuivARB(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectuivARB((UInt32)id, (int)pname, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectuivARB(UInt32 id, int pname, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectuivARB((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetQueryObjectuivARB(Int32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectuivARB((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectuivARB(UInt32 id, int pname, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectuivARB((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetQueryObjectuivARB(Int32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectuivARB((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteObjectARB(UInt32 obj)
        {
            Delegates.glDeleteObjectARB((UInt32)obj);
        }

        public static 
        void glDeleteObjectARB(Int32 obj)
        {
            Delegates.glDeleteObjectARB((UInt32)obj);
        }

        public static 
        Int32 glGetHandleARB(int pname)
        {
            return Delegates.glGetHandleARB((int)pname);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDetachObjectARB(UInt32 containerObj, UInt32 attachedObj)
        {
            Delegates.glDetachObjectARB((UInt32)containerObj, (UInt32)attachedObj);
        }

        public static 
        void glDetachObjectARB(Int32 containerObj, Int32 attachedObj)
        {
            Delegates.glDetachObjectARB((UInt32)containerObj, (UInt32)attachedObj);
        }

        public static 
        Int32 glCreateShaderObjectARB(int shaderType)
        {
            return Delegates.glCreateShaderObjectARB((int)shaderType);
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderSourceARB(UInt32 shaderObj, Int32 count, System.String[] @string, IntPtr length)
        {
            unsafe
            {
                Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length);
            }
        }

        public static 
        void glShaderSourceARB(Int32 shaderObj, Int32 count, System.String[] @string, IntPtr length)
        {
            unsafe
            {
                Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderSourceARB(UInt32 shaderObj, Int32 count, System.String[] @string, Int32[] length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        public static 
        void glShaderSourceARB(Int32 shaderObj, Int32 count, System.String[] @string, Int32[] length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderSourceARB(UInt32 shaderObj, Int32 count, System.String[] @string, ref Int32 length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        public static 
        void glShaderSourceARB(Int32 shaderObj, Int32 count, System.String[] @string, ref Int32 length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glCompileShaderARB(UInt32 shaderObj)
        {
            Delegates.glCompileShaderARB((UInt32)shaderObj);
        }

        public static 
        void glCompileShaderARB(Int32 shaderObj)
        {
            Delegates.glCompileShaderARB((UInt32)shaderObj);
        }

        public static 
        Int32 glCreateProgramObjectARB()
        {
            return Delegates.glCreateProgramObjectARB();
        }

        [System.CLSCompliant(false)]
        public static 
        void glAttachObjectARB(UInt32 containerObj, UInt32 obj)
        {
            Delegates.glAttachObjectARB((UInt32)containerObj, (UInt32)obj);
        }

        public static 
        void glAttachObjectARB(Int32 containerObj, Int32 obj)
        {
            Delegates.glAttachObjectARB((UInt32)containerObj, (UInt32)obj);
        }

        [System.CLSCompliant(false)]
        public static 
        void glLinkProgramARB(UInt32 programObj)
        {
            Delegates.glLinkProgramARB((UInt32)programObj);
        }

        public static 
        void glLinkProgramARB(Int32 programObj)
        {
            Delegates.glLinkProgramARB((UInt32)programObj);
        }

        [System.CLSCompliant(false)]
        public static 
        void glUseProgramObjectARB(UInt32 programObj)
        {
            Delegates.glUseProgramObjectARB((UInt32)programObj);
        }

        public static 
        void glUseProgramObjectARB(Int32 programObj)
        {
            Delegates.glUseProgramObjectARB((UInt32)programObj);
        }

        [System.CLSCompliant(false)]
        public static 
        void glValidateProgramARB(UInt32 programObj)
        {
            Delegates.glValidateProgramARB((UInt32)programObj);
        }

        public static 
        void glValidateProgramARB(Int32 programObj)
        {
            Delegates.glValidateProgramARB((UInt32)programObj);
        }

        public static 
        void glUniform1fARB(Int32 location, Single v0)
        {
            Delegates.glUniform1fARB((Int32)location, (Single)v0);
        }

        public static 
        void glUniform2fARB(Int32 location, Single v0, Single v1)
        {
            Delegates.glUniform2fARB((Int32)location, (Single)v0, (Single)v1);
        }

        public static 
        void glUniform3fARB(Int32 location, Single v0, Single v1, Single v2)
        {
            Delegates.glUniform3fARB((Int32)location, (Single)v0, (Single)v1, (Single)v2);
        }

        public static 
        void glUniform4fARB(Int32 location, Single v0, Single v1, Single v2, Single v3)
        {
            Delegates.glUniform4fARB((Int32)location, (Single)v0, (Single)v1, (Single)v2, (Single)v3);
        }

        public static 
        void glUniform1iARB(Int32 location, Int32 v0)
        {
            Delegates.glUniform1iARB((Int32)location, (Int32)v0);
        }

        public static 
        void glUniform2iARB(Int32 location, Int32 v0, Int32 v1)
        {
            Delegates.glUniform2iARB((Int32)location, (Int32)v0, (Int32)v1);
        }

        public static 
        void glUniform3iARB(Int32 location, Int32 v0, Int32 v1, Int32 v2)
        {
            Delegates.glUniform3iARB((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2);
        }

        public static 
        void glUniform4iARB(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
        {
            Delegates.glUniform4iARB((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2, (Int32)v3);
        }

        public static 
        void glUniform1fvARB(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value);
            }
        }

        public static 
        void glUniform1fvARB(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform1fvARB(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2fvARB(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value);
            }
        }

        public static 
        void glUniform2fvARB(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2fvARB(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3fvARB(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value);
            }
        }

        public static 
        void glUniform3fvARB(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3fvARB(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4fvARB(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value);
            }
        }

        public static 
        void glUniform4fvARB(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4fvARB(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniform1ivARB(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value);
            }
        }

        public static 
        void glUniform1ivARB(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform1ivARB(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2ivARB(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value);
            }
        }

        public static 
        void glUniform2ivARB(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2ivARB(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3ivARB(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value);
            }
        }

        public static 
        void glUniform3ivARB(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3ivARB(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4ivARB(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value);
            }
        }

        public static 
        void glUniform4ivARB(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4ivARB(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix2fvARB(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix2fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix2fvARB(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix2fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix2fvARB(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix2fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix3fvARB(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix3fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix3fvARB(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix3fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix3fvARB(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix3fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix4fvARB(Int32 location, Int32 count, Int32 transpose, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniformMatrix4fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value);
            }
        }

        public static 
        void glUniformMatrix4fvARB(Int32 location, Int32 count, Int32 transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix4fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glUniformMatrix4fvARB(Int32 location, Int32 count, Int32 transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix4fvARB((Int32)location, (Int32)count, (Int32)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectParameterfvARB(UInt32 obj, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetObjectParameterfvARB((UInt32)obj, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetObjectParameterfvARB(Int32 obj, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetObjectParameterfvARB((UInt32)obj, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectParameterfvARB(UInt32 obj, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetObjectParameterfvARB((UInt32)obj, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetObjectParameterfvARB(Int32 obj, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetObjectParameterfvARB((UInt32)obj, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectParameterfvARB(UInt32 obj, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetObjectParameterfvARB((UInt32)obj, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetObjectParameterfvARB(Int32 obj, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetObjectParameterfvARB((UInt32)obj, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectParameterivARB(UInt32 obj, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetObjectParameterivARB((UInt32)obj, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetObjectParameterivARB(Int32 obj, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetObjectParameterivARB((UInt32)obj, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectParameterivARB(UInt32 obj, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetObjectParameterivARB((UInt32)obj, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetObjectParameterivARB(Int32 obj, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetObjectParameterivARB((UInt32)obj, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectParameterivARB(UInt32 obj, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetObjectParameterivARB((UInt32)obj, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetObjectParameterivARB(Int32 obj, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetObjectParameterivARB((UInt32)obj, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInfoLogARB(UInt32 obj, Int32 maxLength, [Out] IntPtr length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder)infoLog);
            }
        }

        public static 
        void glGetInfoLogARB(Int32 obj, Int32 maxLength, [Out] IntPtr length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder)infoLog);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInfoLogARB(UInt32 obj, Int32 maxLength, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        public static 
        void glGetInfoLogARB(Int32 obj, Int32 maxLength, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInfoLogARB(UInt32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetInfoLogARB(Int32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] IntPtr count, [Out] IntPtr obj)
        {
            unsafe
            {
                Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] IntPtr count, [Out] IntPtr obj)
        {
            unsafe
            {
                Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] IntPtr count, [Out] UInt32[] obj)
        {
            unsafe
            {
                fixed (UInt32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
                }
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] IntPtr count, [Out] Int32[] obj)
        {
            unsafe
            {
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] IntPtr count, [Out] out UInt32 obj)
        {
            unsafe
            {
                fixed (UInt32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] IntPtr count, [Out] out Int32 obj)
        {
            unsafe
            {
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] Int32[] count, [Out] IntPtr obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
                }
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] Int32[] count, [Out] IntPtr obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] Int32[] count, [Out] UInt32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (UInt32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                }
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] Int32[] count, [Out] Int32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] Int32[] count, [Out] out UInt32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (UInt32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] Int32[] count, [Out] out Int32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    obj = *obj_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] IntPtr obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] IntPtr obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj);
                    count = *count_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] UInt32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (UInt32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] Int32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetAttachedObjectsARB(UInt32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] out UInt32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (UInt32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                    obj = *obj_ptr;
                }
            }
        }

        public static 
        void glGetAttachedObjectsARB(Int32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] out Int32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                    obj = *obj_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGetUniformLocationARB(UInt32 programObj, System.String name)
        {
            return Delegates.glGetUniformLocationARB((UInt32)programObj, (System.String)name);
        }

        public static 
        Int32 glGetUniformLocationARB(Int32 programObj, System.String name)
        {
            return Delegates.glGetUniformLocationARB((UInt32)programObj, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveUniformARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveUniformARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformfvARB(UInt32 programObj, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params);
            }
        }

        public static 
        void glGetUniformfvARB(Int32 programObj, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformfvARB(UInt32 programObj, Int32 location, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetUniformfvARB(Int32 programObj, Int32 location, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformfvARB(UInt32 programObj, Int32 location, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetUniformfvARB(Int32 programObj, Int32 location, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformivARB(UInt32 programObj, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params);
            }
        }

        public static 
        void glGetUniformivARB(Int32 programObj, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformivARB(UInt32 programObj, Int32 location, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetUniformivARB(Int32 programObj, Int32 location, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformivARB(UInt32 programObj, Int32 location, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetUniformivARB(Int32 programObj, Int32 location, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderSourceARB(UInt32 obj, Int32 maxLength, [Out] IntPtr length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder[])source);
            }
        }

        public static 
        void glGetShaderSourceARB(Int32 obj, Int32 maxLength, [Out] IntPtr length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder[])source);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderSourceARB(UInt32 obj, Int32 maxLength, [Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                }
            }
        }

        public static 
        void glGetShaderSourceARB(Int32 obj, Int32 maxLength, [Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetShaderSourceARB(UInt32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetShaderSourceARB(Int32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindAttribLocationARB(UInt32 programObj, UInt32 index, System.String name)
        {
            Delegates.glBindAttribLocationARB((UInt32)programObj, (UInt32)index, (System.String)name);
        }

        public static 
        void glBindAttribLocationARB(Int32 programObj, Int32 index, System.String name)
        {
            Delegates.glBindAttribLocationARB((UInt32)programObj, (UInt32)index, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveAttribARB(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveAttribARB(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGetAttribLocationARB(UInt32 programObj, System.String name)
        {
            return Delegates.glGetAttribLocationARB((UInt32)programObj, (System.String)name);
        }

        public static 
        Int32 glGetAttribLocationARB(Int32 programObj, System.String name)
        {
            return Delegates.glGetAttribLocationARB((UInt32)programObj, (System.String)name);
        }

        public static 
        void glDrawBuffersARB(Int32 n, IntPtr bufs)
        {
            unsafe
            {
                Delegates.glDrawBuffersARB((Int32)n, (int*)bufs);
            }
        }

        public static 
        void glDrawBuffersARB(Int32 n, int[] bufs)
        {
            unsafe
            {
                fixed (int* bufs_ptr = bufs)
                {
                    Delegates.glDrawBuffersARB((Int32)n, (int*)bufs_ptr);
                }
            }
        }

        public static 
        void glDrawBuffersARB(Int32 n, ref int bufs)
        {
            unsafe
            {
                fixed (int* bufs_ptr = &bufs)
                {
                    Delegates.glDrawBuffersARB((Int32)n, (int*)bufs_ptr);
                }
            }
        }

        public static 
        void glClampColorARB(int target, int clamp)
        {
            Delegates.glClampColorARB((int)target, (int)clamp);
        }

        public static 
        void glBlendColorEXT(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glBlendColorEXT((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void glPolygonOffsetEXT(Single factor, Single bias)
        {
            Delegates.glPolygonOffsetEXT((Single)factor, (Single)bias);
        }

        public static 
        void glTexImage3DEXT(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexImage3DEXT((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexImage3DEXT(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexImage3DEXT((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glTexSubImage3DEXT(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexSubImage3DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexSubImage3DEXT(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage3DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glTexSubImage1DEXT(int target, Int32 level, Int32 xoffset, Int32 width, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexSubImage1DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)width, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexSubImage1DEXT(int target, Int32 level, Int32 xoffset, Int32 width, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage1DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)width, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glTexSubImage2DEXT(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexSubImage2DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexSubImage2DEXT(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage2DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glCopyTexImage1DEXT(int target, Int32 level, int internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
        {
            Delegates.glCopyTexImage1DEXT((int)target, (Int32)level, (int)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)border);
        }

        public static 
        void glCopyTexImage2DEXT(int target, Int32 level, int internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
        {
            Delegates.glCopyTexImage2DEXT((int)target, (Int32)level, (int)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height, (Int32)border);
        }

        public static 
        void glCopyTexSubImage1DEXT(int target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyTexSubImage1DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void glCopyTexSubImage2DEXT(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyTexSubImage2DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void glCopyTexSubImage3DEXT(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyTexSubImage3DEXT((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void glGetHistogramEXT(int target, Int32 reset, int format, int type, [Out] IntPtr values)
        {
            unsafe
            {
                Delegates.glGetHistogramEXT((int)target, (Int32)reset, (int)format, (int)type, (IntPtr)values);
            }
        }

        public static 
        void glGetHistogramEXT(int target, Int32 reset, int format, int type, [In, Out] object values)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle values_ptr = System.Runtime.InteropServices.GCHandle.Alloc(values, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetHistogramEXT((int)target, (Int32)reset, (int)format, (int)type, (IntPtr)values_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    values_ptr.Free();
                }
            }
        }

        public static 
        void glGetHistogramParameterfvEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetHistogramParameterfvEXT((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetHistogramParameterfvEXT(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetHistogramParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetHistogramParameterfvEXT(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetHistogramParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetHistogramParameterivEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetHistogramParameterivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetHistogramParameterivEXT(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetHistogramParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetHistogramParameterivEXT(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetHistogramParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMinmaxEXT(int target, Int32 reset, int format, int type, [Out] IntPtr values)
        {
            unsafe
            {
                Delegates.glGetMinmaxEXT((int)target, (Int32)reset, (int)format, (int)type, (IntPtr)values);
            }
        }

        public static 
        void glGetMinmaxEXT(int target, Int32 reset, int format, int type, [In, Out] object values)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle values_ptr = System.Runtime.InteropServices.GCHandle.Alloc(values, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetMinmaxEXT((int)target, (Int32)reset, (int)format, (int)type, (IntPtr)values_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    values_ptr.Free();
                }
            }
        }

        public static 
        void glGetMinmaxParameterfvEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMinmaxParameterfvEXT((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetMinmaxParameterfvEXT(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetMinmaxParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMinmaxParameterfvEXT(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetMinmaxParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMinmaxParameterivEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMinmaxParameterivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetMinmaxParameterivEXT(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetMinmaxParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMinmaxParameterivEXT(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetMinmaxParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glHistogramEXT(int target, Int32 width, int internalformat, Int32 sink)
        {
            Delegates.glHistogramEXT((int)target, (Int32)width, (int)internalformat, (Int32)sink);
        }

        public static 
        void glMinmaxEXT(int target, int internalformat, Int32 sink)
        {
            Delegates.glMinmaxEXT((int)target, (int)internalformat, (Int32)sink);
        }

        public static 
        void glResetHistogramEXT(int target)
        {
            Delegates.glResetHistogramEXT((int)target);
        }

        public static 
        void glResetMinmaxEXT(int target)
        {
            Delegates.glResetMinmaxEXT((int)target);
        }

        public static 
        void glConvolutionFilter1DEXT(int target, int internalformat, Int32 width, int format, int type, IntPtr image)
        {
            unsafe
            {
                Delegates.glConvolutionFilter1DEXT((int)target, (int)internalformat, (Int32)width, (int)format, (int)type, (IntPtr)image);
            }
        }

        public static 
        void glConvolutionFilter1DEXT(int target, int internalformat, Int32 width, int format, int type, [In, Out] object image)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glConvolutionFilter1DEXT((int)target, (int)internalformat, (Int32)width, (int)format, (int)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }

        public static 
        void glConvolutionFilter2DEXT(int target, int internalformat, Int32 width, Int32 height, int format, int type, IntPtr image)
        {
            unsafe
            {
                Delegates.glConvolutionFilter2DEXT((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)image);
            }
        }

        public static 
        void glConvolutionFilter2DEXT(int target, int internalformat, Int32 width, Int32 height, int format, int type, [In, Out] object image)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glConvolutionFilter2DEXT((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }

        public static 
        void glConvolutionParameterfEXT(int target, int pname, Single @params)
        {
            Delegates.glConvolutionParameterfEXT((int)target, (int)pname, (Single)@params);
        }

        public static 
        void glConvolutionParameterfvEXT(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glConvolutionParameterfvEXT((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glConvolutionParameterfvEXT(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glConvolutionParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glConvolutionParameterfvEXT(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glConvolutionParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glConvolutionParameteriEXT(int target, int pname, Int32 @params)
        {
            Delegates.glConvolutionParameteriEXT((int)target, (int)pname, (Int32)@params);
        }

        public static 
        void glConvolutionParameterivEXT(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glConvolutionParameterivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glConvolutionParameterivEXT(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glConvolutionParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glConvolutionParameterivEXT(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glConvolutionParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glCopyConvolutionFilter1DEXT(int target, int internalformat, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyConvolutionFilter1DEXT((int)target, (int)internalformat, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void glCopyConvolutionFilter2DEXT(int target, int internalformat, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyConvolutionFilter2DEXT((int)target, (int)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void glGetConvolutionFilterEXT(int target, int format, int type, [Out] IntPtr image)
        {
            unsafe
            {
                Delegates.glGetConvolutionFilterEXT((int)target, (int)format, (int)type, (IntPtr)image);
            }
        }

        public static 
        void glGetConvolutionFilterEXT(int target, int format, int type, [In, Out] object image)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetConvolutionFilterEXT((int)target, (int)format, (int)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }
        }

        public static 
        void glGetConvolutionParameterfvEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetConvolutionParameterfvEXT((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetConvolutionParameterfvEXT(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetConvolutionParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetConvolutionParameterfvEXT(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetConvolutionParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetConvolutionParameterivEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetConvolutionParameterivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetConvolutionParameterivEXT(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetConvolutionParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetConvolutionParameterivEXT(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetConvolutionParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetSeparableFilterEXT(int target, int format, int type, [Out] IntPtr row, [Out] IntPtr column, [Out] IntPtr span)
        {
            unsafe
            {
                Delegates.glGetSeparableFilterEXT((int)target, (int)format, (int)type, (IntPtr)row, (IntPtr)column, (IntPtr)span);
            }
        }

        public static 
        void glGetSeparableFilterEXT(int target, int format, int type, [Out] IntPtr row, [Out] IntPtr column, [In, Out] object span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((int)target, (int)format, (int)type, (IntPtr)row, (IntPtr)column, (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    span_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilterEXT(int target, int format, int type, [Out] IntPtr row, [In, Out] object column, [Out] IntPtr span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((int)target, (int)format, (int)type, (IntPtr)row, (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span);
                }
                finally
                {
                    column_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilterEXT(int target, int format, int type, [Out] IntPtr row, [In, Out] object column, [In, Out] object span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((int)target, (int)format, (int)type, (IntPtr)row, (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    column_ptr.Free();
                    span_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilterEXT(int target, int format, int type, [In, Out] object row, [Out] IntPtr column, [Out] IntPtr span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((int)target, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column, (IntPtr)span);
                }
                finally
                {
                    row_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilterEXT(int target, int format, int type, [In, Out] object row, [Out] IntPtr column, [In, Out] object span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((int)target, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column, (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    span_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilterEXT(int target, int format, int type, [In, Out] object row, [In, Out] object column, [Out] IntPtr span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((int)target, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span);
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                }
            }
        }

        public static 
        void glGetSeparableFilterEXT(int target, int format, int type, [In, Out] object row, [In, Out] object column, [In, Out] object span)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((int)target, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                    span_ptr.Free();
                }
            }
        }

        public static 
        void glSeparableFilter2DEXT(int target, int internalformat, Int32 width, Int32 height, int format, int type, IntPtr row, IntPtr column)
        {
            unsafe
            {
                Delegates.glSeparableFilter2DEXT((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)row, (IntPtr)column);
            }
        }

        public static 
        void glSeparableFilter2DEXT(int target, int internalformat, Int32 width, Int32 height, int format, int type, IntPtr row, [In, Out] object column)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2DEXT((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)row, (IntPtr)column_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    column_ptr.Free();
                }
            }
        }

        public static 
        void glSeparableFilter2DEXT(int target, int internalformat, Int32 width, Int32 height, int format, int type, [In, Out] object row, IntPtr column)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2DEXT((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column);
                }
                finally
                {
                    row_ptr.Free();
                }
            }
        }

        public static 
        void glSeparableFilter2DEXT(int target, int internalformat, Int32 width, Int32 height, int format, int type, [In, Out] object row, [In, Out] object column)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2DEXT((int)target, (int)internalformat, (Int32)width, (Int32)height, (int)format, (int)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                }
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, IntPtr textures, [Out] IntPtr residences)
        {
            unsafe
            {
                return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures, (Int32*)residences);
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, IntPtr textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, IntPtr textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, UInt32[] textures, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences);
                }
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, Int32[] textures, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, UInt32[] textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, Int32[] textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, UInt32[] textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, Int32[] textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, ref UInt32 textures, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences);
                }
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, ref Int32 textures, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, ref UInt32 textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, ref Int32 textures, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, ref UInt32 textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glAreTexturesResidentEXT(Int32 n, ref Int32 textures, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindTextureEXT(int target, UInt32 texture)
        {
            Delegates.glBindTextureEXT((int)target, (UInt32)texture);
        }

        public static 
        void glBindTextureEXT(int target, Int32 texture)
        {
            Delegates.glBindTextureEXT((int)target, (UInt32)texture);
        }

        public static 
        void glDeleteTexturesEXT(Int32 n, IntPtr textures)
        {
            unsafe
            {
                Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteTexturesEXT(Int32 n, UInt32[] textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void glDeleteTexturesEXT(Int32 n, Int32[] textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteTexturesEXT(Int32 n, ref UInt32 textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void glDeleteTexturesEXT(Int32 n, ref Int32 textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void glGenTexturesEXT(Int32 n, [Out] IntPtr textures)
        {
            unsafe
            {
                Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenTexturesEXT(Int32 n, [Out] UInt32[] textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void glGenTexturesEXT(Int32 n, [Out] Int32[] textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenTexturesEXT(Int32 n, [Out] out UInt32 textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                    textures = *textures_ptr;
                }
            }
        }

        public static 
        void glGenTexturesEXT(Int32 n, [Out] out Int32 textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                    textures = *textures_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsTextureEXT(UInt32 texture)
        {
            return Delegates.glIsTextureEXT((UInt32)texture);
        }

        public static 
        Int32 glIsTextureEXT(Int32 texture)
        {
            return Delegates.glIsTextureEXT((UInt32)texture);
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, IntPtr textures, IntPtr priorities)
        {
            unsafe
            {
                Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities);
            }
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, IntPtr textures, Single[] priorities)
        {
            unsafe
            {
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, IntPtr textures, ref Single priorities)
        {
            unsafe
            {
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTexturesEXT(Int32 n, UInt32[] textures, IntPtr priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
                }
            }
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, Int32[] textures, IntPtr priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTexturesEXT(Int32 n, UInt32[] textures, Single[] priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, Int32[] textures, Single[] priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTexturesEXT(Int32 n, UInt32[] textures, ref Single priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, Int32[] textures, ref Single priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTexturesEXT(Int32 n, ref UInt32 textures, IntPtr priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
                }
            }
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, ref Int32 textures, IntPtr priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTexturesEXT(Int32 n, ref UInt32 textures, Single[] priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, ref Int32 textures, Single[] priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrioritizeTexturesEXT(Int32 n, ref UInt32 textures, ref Single priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glPrioritizeTexturesEXT(Int32 n, ref Int32 textures, ref Single priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void glArrayElementEXT(Int32 i)
        {
            Delegates.glArrayElementEXT((Int32)i);
        }

        public static 
        void glColorPointerEXT(Int32 size, int type, Int32 stride, Int32 count, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glColorPointerEXT((Int32)size, (int)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }
        }

        public static 
        void glColorPointerEXT(Int32 size, int type, Int32 stride, Int32 count, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorPointerEXT((Int32)size, (int)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glDrawArraysEXT(int mode, Int32 first, Int32 count)
        {
            Delegates.glDrawArraysEXT((int)mode, (Int32)first, (Int32)count);
        }

        public static 
        void glEdgeFlagPointerEXT(Int32 stride, Int32 count, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glEdgeFlagPointerEXT((Int32)stride, (Int32)count, (Int32*)pointer);
            }
        }

        public static 
        void glEdgeFlagPointerEXT(Int32 stride, Int32 count, Int32[] pointer)
        {
            unsafe
            {
                fixed (Int32* pointer_ptr = pointer)
                {
                    Delegates.glEdgeFlagPointerEXT((Int32)stride, (Int32)count, (Int32*)pointer_ptr);
                }
            }
        }

        public static 
        void glEdgeFlagPointerEXT(Int32 stride, Int32 count, ref Int32 pointer)
        {
            unsafe
            {
                fixed (Int32* pointer_ptr = &pointer)
                {
                    Delegates.glEdgeFlagPointerEXT((Int32)stride, (Int32)count, (Int32*)pointer_ptr);
                }
            }
        }

        public static 
        void glGetPointervEXT(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetPointervEXT((int)pname, (IntPtr)@params);
            }
        }

        public static 
        void glGetPointervEXT(int pname, [In, Out] object @params)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetPointervEXT((int)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }
        }

        public static 
        void glIndexPointerEXT(int type, Int32 stride, Int32 count, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glIndexPointerEXT((int)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }
        }

        public static 
        void glIndexPointerEXT(int type, Int32 stride, Int32 count, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glIndexPointerEXT((int)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glNormalPointerEXT(int type, Int32 stride, Int32 count, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glNormalPointerEXT((int)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }
        }

        public static 
        void glNormalPointerEXT(int type, Int32 stride, Int32 count, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glNormalPointerEXT((int)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glTexCoordPointerEXT(Int32 size, int type, Int32 stride, Int32 count, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glTexCoordPointerEXT((Int32)size, (int)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }
        }

        public static 
        void glTexCoordPointerEXT(Int32 size, int type, Int32 stride, Int32 count, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexCoordPointerEXT((Int32)size, (int)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexPointerEXT(Int32 size, int type, Int32 stride, Int32 count, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexPointerEXT((Int32)size, (int)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexPointerEXT(Int32 size, int type, Int32 stride, Int32 count, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexPointerEXT((Int32)size, (int)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glBlendEquationEXT(int mode)
        {
            Delegates.glBlendEquationEXT((int)mode);
        }

        public static 
        void glPointParameterfEXT(int pname, Single param)
        {
            Delegates.glPointParameterfEXT((int)pname, (Single)param);
        }

        public static 
        void glPointParameterfvEXT(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPointParameterfvEXT((int)pname, (Single*)@params);
            }
        }

        public static 
        void glPointParameterfvEXT(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glPointParameterfvEXT((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glPointParameterfvEXT(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glPointParameterfvEXT((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glColorSubTableEXT(int target, Int32 start, Int32 count, int format, int type, IntPtr data)
        {
            unsafe
            {
                Delegates.glColorSubTableEXT((int)target, (Int32)start, (Int32)count, (int)format, (int)type, (IntPtr)data);
            }
        }

        public static 
        void glColorSubTableEXT(int target, Int32 start, Int32 count, int format, int type, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorSubTableEXT((int)target, (Int32)start, (Int32)count, (int)format, (int)type, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glCopyColorSubTableEXT(int target, Int32 start, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyColorSubTableEXT((int)target, (Int32)start, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void glColorTableEXT(int target, int internalFormat, Int32 width, int format, int type, IntPtr table)
        {
            unsafe
            {
                Delegates.glColorTableEXT((int)target, (int)internalFormat, (Int32)width, (int)format, (int)type, (IntPtr)table);
            }
        }

        public static 
        void glColorTableEXT(int target, int internalFormat, Int32 width, int format, int type, [In, Out] object table)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorTableEXT((int)target, (int)internalFormat, (Int32)width, (int)format, (int)type, (IntPtr)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }
        }

        public static 
        void glGetColorTableEXT(int target, int format, int type, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetColorTableEXT((int)target, (int)format, (int)type, (IntPtr)data);
            }
        }

        public static 
        void glGetColorTableEXT(int target, int format, int type, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetColorTableEXT((int)target, (int)format, (int)type, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glGetColorTableParameterivEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetColorTableParameterivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetColorTableParameterivEXT(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetColorTableParameterivEXT(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetColorTableParameterfvEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetColorTableParameterfvEXT((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetColorTableParameterfvEXT(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetColorTableParameterfvEXT(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glIndexMaterialEXT(int face, int mode)
        {
            Delegates.glIndexMaterialEXT((int)face, (int)mode);
        }

        public static 
        void glIndexFuncEXT(int func, Single @ref)
        {
            Delegates.glIndexFuncEXT((int)func, (Single)@ref);
        }

        public static 
        void glLockArraysEXT(Int32 first, Int32 count)
        {
            Delegates.glLockArraysEXT((Int32)first, (Int32)count);
        }

        public static 
        void glUnlockArraysEXT()
        {
            Delegates.glUnlockArraysEXT();
        }

        public static 
        void glCullParameterdvEXT(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glCullParameterdvEXT((int)pname, (Double*)@params);
            }
        }

        public static 
        void glCullParameterdvEXT(int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glCullParameterdvEXT((int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glCullParameterdvEXT(int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glCullParameterdvEXT((int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glCullParameterfvEXT(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glCullParameterfvEXT((int)pname, (Single*)@params);
            }
        }

        public static 
        void glCullParameterfvEXT(int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glCullParameterfvEXT((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glCullParameterfvEXT(int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glCullParameterfvEXT((int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDrawRangeElementsEXT(int mode, UInt32 start, UInt32 end, Int32 count, int type, IntPtr indices)
        {
            unsafe
            {
                Delegates.glDrawRangeElementsEXT((int)mode, (UInt32)start, (UInt32)end, (Int32)count, (int)type, (IntPtr)indices);
            }
        }

        public static 
        void glDrawRangeElementsEXT(int mode, Int32 start, Int32 end, Int32 count, int type, IntPtr indices)
        {
            unsafe
            {
                Delegates.glDrawRangeElementsEXT((int)mode, (UInt32)start, (UInt32)end, (Int32)count, (int)type, (IntPtr)indices);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDrawRangeElementsEXT(int mode, UInt32 start, UInt32 end, Int32 count, int type, [In, Out] object indices)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawRangeElementsEXT((int)mode, (UInt32)start, (UInt32)end, (Int32)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        public static 
        void glDrawRangeElementsEXT(int mode, Int32 start, Int32 end, Int32 count, int type, [In, Out] object indices)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawRangeElementsEXT((int)mode, (UInt32)start, (UInt32)end, (Int32)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        public static 
        void glApplyTextureEXT(int mode)
        {
            Delegates.glApplyTextureEXT((int)mode);
        }

        public static 
        void glTextureLightEXT(int pname)
        {
            Delegates.glTextureLightEXT((int)pname);
        }

        public static 
        void glTextureMaterialEXT(int face, int mode)
        {
            Delegates.glTextureMaterialEXT((int)face, (int)mode);
        }

        public static 
        void glPixelTransformParameteriEXT(int target, int pname, Int32 param)
        {
            Delegates.glPixelTransformParameteriEXT((int)target, (int)pname, (Int32)param);
        }

        public static 
        void glPixelTransformParameterfEXT(int target, int pname, Single param)
        {
            Delegates.glPixelTransformParameterfEXT((int)target, (int)pname, (Single)param);
        }

        public static 
        void glPixelTransformParameterivEXT(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPixelTransformParameterivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glPixelTransformParameterivEXT(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glPixelTransformParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glPixelTransformParameterivEXT(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glPixelTransformParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glPixelTransformParameterfvEXT(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPixelTransformParameterfvEXT((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glPixelTransformParameterfvEXT(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glPixelTransformParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glPixelTransformParameterfvEXT(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glPixelTransformParameterfvEXT((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3bEXT(SByte red, SByte green, SByte blue)
        {
            Delegates.glSecondaryColor3bEXT((SByte)red, (SByte)green, (SByte)blue);
        }

        public static 
        void glSecondaryColor3bEXT(Byte red, Byte green, Byte blue)
        {
            Delegates.glSecondaryColor3bEXT((SByte)red, (SByte)green, (SByte)blue);
        }

        public static 
        void glSecondaryColor3bvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3bvEXT((SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3bvEXT(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3bvEXT(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3bvEXT(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3bvEXT(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3dEXT(Double red, Double green, Double blue)
        {
            Delegates.glSecondaryColor3dEXT((Double)red, (Double)green, (Double)blue);
        }

        public static 
        void glSecondaryColor3dvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3dvEXT((Double*)v);
            }
        }

        public static 
        void glSecondaryColor3dvEXT(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glSecondaryColor3dvEXT((Double*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3dvEXT(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3dvEXT((Double*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3fEXT(Single red, Single green, Single blue)
        {
            Delegates.glSecondaryColor3fEXT((Single)red, (Single)green, (Single)blue);
        }

        public static 
        void glSecondaryColor3fvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3fvEXT((Single*)v);
            }
        }

        public static 
        void glSecondaryColor3fvEXT(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glSecondaryColor3fvEXT((Single*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3fvEXT(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3fvEXT((Single*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3iEXT(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glSecondaryColor3iEXT((Int32)red, (Int32)green, (Int32)blue);
        }

        public static 
        void glSecondaryColor3ivEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3ivEXT((Int32*)v);
            }
        }

        public static 
        void glSecondaryColor3ivEXT(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3ivEXT((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3ivEXT(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3ivEXT((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3sEXT(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glSecondaryColor3sEXT((Int16)red, (Int16)green, (Int16)blue);
        }

        public static 
        void glSecondaryColor3svEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3svEXT((Int16*)v);
            }
        }

        public static 
        void glSecondaryColor3svEXT(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3svEXT((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3svEXT(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3svEXT((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3ubEXT(Byte red, Byte green, Byte blue)
        {
            Delegates.glSecondaryColor3ubEXT((Byte)red, (Byte)green, (Byte)blue);
        }

        public static 
        void glSecondaryColor3ubvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3ubvEXT((Byte*)v);
            }
        }

        public static 
        void glSecondaryColor3ubvEXT(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3ubvEXT((Byte*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3ubvEXT(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3ubvEXT((Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3uiEXT(UInt32 red, UInt32 green, UInt32 blue)
        {
            Delegates.glSecondaryColor3uiEXT((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        public static 
        void glSecondaryColor3uiEXT(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glSecondaryColor3uiEXT((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        public static 
        void glSecondaryColor3uivEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3uivEXT((UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3uivEXT(UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3uivEXT(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3uivEXT(ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3uivEXT(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3usEXT(UInt16 red, UInt16 green, UInt16 blue)
        {
            Delegates.glSecondaryColor3usEXT((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glSecondaryColor3usEXT(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glSecondaryColor3usEXT((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glSecondaryColor3usvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3usvEXT((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3usvEXT(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3usvEXT(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3usvEXT(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3usvEXT(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColorPointerEXT(Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glSecondaryColorPointerEXT((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glSecondaryColorPointerEXT(Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSecondaryColorPointerEXT((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glTextureNormalEXT(int mode)
        {
            Delegates.glTextureNormalEXT((int)mode);
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] IntPtr first, [Out] IntPtr count, Int32 primcount)
        {
            unsafe
            {
                Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first, (Int32*)count, (Int32)primcount);
            }
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] IntPtr first, [Out] Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] IntPtr first, [Out] out Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] Int32[] first, [Out] IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                {
                    Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] Int32[] first, [Out] Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] Int32[] first, [Out] out Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] out Int32 first, [Out] IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                {
                    Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                    first = *first_ptr;
                }
            }
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] out Int32 first, [Out] Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    first = *first_ptr;
                }
            }
        }

        public static 
        void glMultiDrawArraysEXT(int mode, [Out] out Int32 first, [Out] out Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawArraysEXT((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    first = *first_ptr;
                    count = *count_ptr;
                }
            }
        }

        public static 
        void glMultiDrawElementsEXT(int mode, IntPtr count, int type, IntPtr indices, Int32 primcount)
        {
            unsafe
            {
                Delegates.glMultiDrawElementsEXT((int)mode, (Int32*)count, (int)type, (IntPtr)indices, (Int32)primcount);
            }
        }

        public static 
        void glMultiDrawElementsEXT(int mode, IntPtr count, int type, [In, Out] object indices, Int32 primcount)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMultiDrawElementsEXT((int)mode, (Int32*)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        public static 
        void glMultiDrawElementsEXT(int mode, Int32[] count, int type, IntPtr indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawElementsEXT((int)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementsEXT(int mode, Int32[] count, int type, [In, Out] object indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiDrawElementsEXT((int)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiDrawElementsEXT(int mode, ref Int32 count, int type, IntPtr indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawElementsEXT((int)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementsEXT(int mode, ref Int32 count, int type, [In, Out] object indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiDrawElementsEXT((int)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glFogCoordfEXT(Single coord)
        {
            Delegates.glFogCoordfEXT((Single)coord);
        }

        public static 
        void glFogCoordfvEXT(IntPtr coord)
        {
            unsafe
            {
                Delegates.glFogCoordfvEXT((Single*)coord);
            }
        }

        public static 
        void glFogCoordfvEXT(Single[] coord)
        {
            unsafe
            {
                fixed (Single* coord_ptr = coord)
                {
                    Delegates.glFogCoordfvEXT((Single*)coord_ptr);
                }
            }
        }

        public static 
        void glFogCoordfvEXT(ref Single coord)
        {
            unsafe
            {
                fixed (Single* coord_ptr = &coord)
                {
                    Delegates.glFogCoordfvEXT((Single*)coord_ptr);
                }
            }
        }

        public static 
        void glFogCoorddEXT(Double coord)
        {
            Delegates.glFogCoorddEXT((Double)coord);
        }

        public static 
        void glFogCoorddvEXT(IntPtr coord)
        {
            unsafe
            {
                Delegates.glFogCoorddvEXT((Double*)coord);
            }
        }

        public static 
        void glFogCoorddvEXT(Double[] coord)
        {
            unsafe
            {
                fixed (Double* coord_ptr = coord)
                {
                    Delegates.glFogCoorddvEXT((Double*)coord_ptr);
                }
            }
        }

        public static 
        void glFogCoorddvEXT(ref Double coord)
        {
            unsafe
            {
                fixed (Double* coord_ptr = &coord)
                {
                    Delegates.glFogCoorddvEXT((Double*)coord_ptr);
                }
            }
        }

        public static 
        void glFogCoordPointerEXT(int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glFogCoordPointerEXT((int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glFogCoordPointerEXT(int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glFogCoordPointerEXT((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTangent3bEXT(SByte tx, SByte ty, SByte tz)
        {
            Delegates.glTangent3bEXT((SByte)tx, (SByte)ty, (SByte)tz);
        }

        public static 
        void glTangent3bEXT(Byte tx, Byte ty, Byte tz)
        {
            Delegates.glTangent3bEXT((SByte)tx, (SByte)ty, (SByte)tz);
        }

        public static 
        void glTangent3bvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glTangent3bvEXT((SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTangent3bvEXT(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glTangent3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3bvEXT(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glTangent3bvEXT((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTangent3bvEXT(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glTangent3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3bvEXT(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glTangent3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3dEXT(Double tx, Double ty, Double tz)
        {
            Delegates.glTangent3dEXT((Double)tx, (Double)ty, (Double)tz);
        }

        public static 
        void glTangent3dvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glTangent3dvEXT((Double*)v);
            }
        }

        public static 
        void glTangent3dvEXT(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTangent3dvEXT((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3dvEXT(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTangent3dvEXT((Double*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3fEXT(Single tx, Single ty, Single tz)
        {
            Delegates.glTangent3fEXT((Single)tx, (Single)ty, (Single)tz);
        }

        public static 
        void glTangent3fvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glTangent3fvEXT((Single*)v);
            }
        }

        public static 
        void glTangent3fvEXT(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTangent3fvEXT((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3fvEXT(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTangent3fvEXT((Single*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3iEXT(Int32 tx, Int32 ty, Int32 tz)
        {
            Delegates.glTangent3iEXT((Int32)tx, (Int32)ty, (Int32)tz);
        }

        public static 
        void glTangent3ivEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glTangent3ivEXT((Int32*)v);
            }
        }

        public static 
        void glTangent3ivEXT(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTangent3ivEXT((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3ivEXT(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTangent3ivEXT((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3sEXT(Int16 tx, Int16 ty, Int16 tz)
        {
            Delegates.glTangent3sEXT((Int16)tx, (Int16)ty, (Int16)tz);
        }

        public static 
        void glTangent3svEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glTangent3svEXT((Int16*)v);
            }
        }

        public static 
        void glTangent3svEXT(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTangent3svEXT((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTangent3svEXT(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTangent3svEXT((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBinormal3bEXT(SByte bx, SByte by, SByte bz)
        {
            Delegates.glBinormal3bEXT((SByte)bx, (SByte)by, (SByte)bz);
        }

        public static 
        void glBinormal3bEXT(Byte bx, Byte by, Byte bz)
        {
            Delegates.glBinormal3bEXT((SByte)bx, (SByte)by, (SByte)bz);
        }

        public static 
        void glBinormal3bvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glBinormal3bvEXT((SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBinormal3bvEXT(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glBinormal3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3bvEXT(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glBinormal3bvEXT((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBinormal3bvEXT(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glBinormal3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3bvEXT(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glBinormal3bvEXT((SByte*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3dEXT(Double bx, Double by, Double bz)
        {
            Delegates.glBinormal3dEXT((Double)bx, (Double)by, (Double)bz);
        }

        public static 
        void glBinormal3dvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glBinormal3dvEXT((Double*)v);
            }
        }

        public static 
        void glBinormal3dvEXT(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glBinormal3dvEXT((Double*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3dvEXT(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glBinormal3dvEXT((Double*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3fEXT(Single bx, Single by, Single bz)
        {
            Delegates.glBinormal3fEXT((Single)bx, (Single)by, (Single)bz);
        }

        public static 
        void glBinormal3fvEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glBinormal3fvEXT((Single*)v);
            }
        }

        public static 
        void glBinormal3fvEXT(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glBinormal3fvEXT((Single*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3fvEXT(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glBinormal3fvEXT((Single*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3iEXT(Int32 bx, Int32 by, Int32 bz)
        {
            Delegates.glBinormal3iEXT((Int32)bx, (Int32)by, (Int32)bz);
        }

        public static 
        void glBinormal3ivEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glBinormal3ivEXT((Int32*)v);
            }
        }

        public static 
        void glBinormal3ivEXT(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glBinormal3ivEXT((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3ivEXT(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glBinormal3ivEXT((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3sEXT(Int16 bx, Int16 by, Int16 bz)
        {
            Delegates.glBinormal3sEXT((Int16)bx, (Int16)by, (Int16)bz);
        }

        public static 
        void glBinormal3svEXT(IntPtr v)
        {
            unsafe
            {
                Delegates.glBinormal3svEXT((Int16*)v);
            }
        }

        public static 
        void glBinormal3svEXT(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glBinormal3svEXT((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glBinormal3svEXT(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glBinormal3svEXT((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glTangentPointerEXT(int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glTangentPointerEXT((int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glTangentPointerEXT(int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTangentPointerEXT((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glBinormalPointerEXT(int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glBinormalPointerEXT((int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glBinormalPointerEXT(int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glBinormalPointerEXT((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glBlendFuncSeparateEXT(int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dfactorAlpha)
        {
            Delegates.glBlendFuncSeparateEXT((int)sfactorRGB, (int)dfactorRGB, (int)sfactorAlpha, (int)dfactorAlpha);
        }

        public static 
        void glVertexWeightfEXT(Single weight)
        {
            Delegates.glVertexWeightfEXT((Single)weight);
        }

        public static 
        void glVertexWeightfvEXT(IntPtr weight)
        {
            unsafe
            {
                Delegates.glVertexWeightfvEXT((Single*)weight);
            }
        }

        public static 
        void glVertexWeightfvEXT(Single[] weight)
        {
            unsafe
            {
                fixed (Single* weight_ptr = weight)
                {
                    Delegates.glVertexWeightfvEXT((Single*)weight_ptr);
                }
            }
        }

        public static 
        void glVertexWeightfvEXT(ref Single weight)
        {
            unsafe
            {
                fixed (Single* weight_ptr = &weight)
                {
                    Delegates.glVertexWeightfvEXT((Single*)weight_ptr);
                }
            }
        }

        public static 
        void glVertexWeightPointerEXT(Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexWeightPointerEXT((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexWeightPointerEXT(Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexWeightPointerEXT((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glSampleMaskEXT(Single value, Int32 invert)
        {
            Delegates.glSampleMaskEXT((Single)value, (Int32)invert);
        }

        public static 
        void glSamplePatternEXT(int pattern)
        {
            Delegates.glSamplePatternEXT((int)pattern);
        }

        public static 
        void glBeginVertexShaderEXT()
        {
            Delegates.glBeginVertexShaderEXT();
        }

        public static 
        void glEndVertexShaderEXT()
        {
            Delegates.glEndVertexShaderEXT();
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindVertexShaderEXT(UInt32 id)
        {
            Delegates.glBindVertexShaderEXT((UInt32)id);
        }

        public static 
        void glBindVertexShaderEXT(Int32 id)
        {
            Delegates.glBindVertexShaderEXT((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGenVertexShadersEXT(UInt32 range)
        {
            return Delegates.glGenVertexShadersEXT((UInt32)range);
        }

        public static 
        Int32 glGenVertexShadersEXT(Int32 range)
        {
            return Delegates.glGenVertexShadersEXT((UInt32)range);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteVertexShaderEXT(UInt32 id)
        {
            Delegates.glDeleteVertexShaderEXT((UInt32)id);
        }

        public static 
        void glDeleteVertexShaderEXT(Int32 id)
        {
            Delegates.glDeleteVertexShaderEXT((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderOp1EXT(int op, UInt32 res, UInt32 arg1)
        {
            Delegates.glShaderOp1EXT((int)op, (UInt32)res, (UInt32)arg1);
        }

        public static 
        void glShaderOp1EXT(int op, Int32 res, Int32 arg1)
        {
            Delegates.glShaderOp1EXT((int)op, (UInt32)res, (UInt32)arg1);
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderOp2EXT(int op, UInt32 res, UInt32 arg1, UInt32 arg2)
        {
            Delegates.glShaderOp2EXT((int)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2);
        }

        public static 
        void glShaderOp2EXT(int op, Int32 res, Int32 arg1, Int32 arg2)
        {
            Delegates.glShaderOp2EXT((int)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2);
        }

        [System.CLSCompliant(false)]
        public static 
        void glShaderOp3EXT(int op, UInt32 res, UInt32 arg1, UInt32 arg2, UInt32 arg3)
        {
            Delegates.glShaderOp3EXT((int)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2, (UInt32)arg3);
        }

        public static 
        void glShaderOp3EXT(int op, Int32 res, Int32 arg1, Int32 arg2, Int32 arg3)
        {
            Delegates.glShaderOp3EXT((int)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2, (UInt32)arg3);
        }

        [System.CLSCompliant(false)]
        public static 
        void glSwizzleEXT(UInt32 res, UInt32 @in, int outX, int outY, int outZ, int outW)
        {
            Delegates.glSwizzleEXT((UInt32)res, (UInt32)@in, (int)outX, (int)outY, (int)outZ, (int)outW);
        }

        public static 
        void glSwizzleEXT(Int32 res, Int32 @in, int outX, int outY, int outZ, int outW)
        {
            Delegates.glSwizzleEXT((UInt32)res, (UInt32)@in, (int)outX, (int)outY, (int)outZ, (int)outW);
        }

        [System.CLSCompliant(false)]
        public static 
        void glWriteMaskEXT(UInt32 res, UInt32 @in, int outX, int outY, int outZ, int outW)
        {
            Delegates.glWriteMaskEXT((UInt32)res, (UInt32)@in, (int)outX, (int)outY, (int)outZ, (int)outW);
        }

        public static 
        void glWriteMaskEXT(Int32 res, Int32 @in, int outX, int outY, int outZ, int outW)
        {
            Delegates.glWriteMaskEXT((UInt32)res, (UInt32)@in, (int)outX, (int)outY, (int)outZ, (int)outW);
        }

        [System.CLSCompliant(false)]
        public static 
        void glInsertComponentEXT(UInt32 res, UInt32 src, UInt32 num)
        {
            Delegates.glInsertComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
        }

        public static 
        void glInsertComponentEXT(Int32 res, Int32 src, Int32 num)
        {
            Delegates.glInsertComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
        }

        [System.CLSCompliant(false)]
        public static 
        void glExtractComponentEXT(UInt32 res, UInt32 src, UInt32 num)
        {
            Delegates.glExtractComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
        }

        public static 
        void glExtractComponentEXT(Int32 res, Int32 src, Int32 num)
        {
            Delegates.glExtractComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGenSymbolsEXT(int datatype, int storagetype, int range, UInt32 components)
        {
            return Delegates.glGenSymbolsEXT((int)datatype, (int)storagetype, (int)range, (UInt32)components);
        }

        public static 
        Int32 glGenSymbolsEXT(int datatype, int storagetype, int range, Int32 components)
        {
            return Delegates.glGenSymbolsEXT((int)datatype, (int)storagetype, (int)range, (UInt32)components);
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetInvariantEXT(UInt32 id, int type, IntPtr addr)
        {
            unsafe
            {
                Delegates.glSetInvariantEXT((UInt32)id, (int)type, (IntPtr)addr);
            }
        }

        public static 
        void glSetInvariantEXT(Int32 id, int type, IntPtr addr)
        {
            unsafe
            {
                Delegates.glSetInvariantEXT((UInt32)id, (int)type, (IntPtr)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetInvariantEXT(UInt32 id, int type, [In, Out] object addr)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSetInvariantEXT((UInt32)id, (int)type, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }
        }

        public static 
        void glSetInvariantEXT(Int32 id, int type, [In, Out] object addr)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSetInvariantEXT((UInt32)id, (int)type, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetLocalConstantEXT(UInt32 id, int type, IntPtr addr)
        {
            unsafe
            {
                Delegates.glSetLocalConstantEXT((UInt32)id, (int)type, (IntPtr)addr);
            }
        }

        public static 
        void glSetLocalConstantEXT(Int32 id, int type, IntPtr addr)
        {
            unsafe
            {
                Delegates.glSetLocalConstantEXT((UInt32)id, (int)type, (IntPtr)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetLocalConstantEXT(UInt32 id, int type, [In, Out] object addr)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSetLocalConstantEXT((UInt32)id, (int)type, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }
        }

        public static 
        void glSetLocalConstantEXT(Int32 id, int type, [In, Out] object addr)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSetLocalConstantEXT((UInt32)id, (int)type, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantbvEXT(UInt32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr);
            }
        }

        public static 
        void glVariantbvEXT(Int32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantbvEXT(UInt32 id, SByte[] addr)
        {
            unsafe
            {
                fixed (SByte* addr_ptr = addr)
                {
                    Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantbvEXT(Int32 id, Byte[] addr)
        {
            unsafe
            {
                fixed (Byte* addr_ptr = addr)
                {
                    Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantbvEXT(UInt32 id, ref SByte addr)
        {
            unsafe
            {
                fixed (SByte* addr_ptr = &addr)
                {
                    Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantbvEXT(Int32 id, ref Byte addr)
        {
            unsafe
            {
                fixed (Byte* addr_ptr = &addr)
                {
                    Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantsvEXT(UInt32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr);
            }
        }

        public static 
        void glVariantsvEXT(Int32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantsvEXT(UInt32 id, Int16[] addr)
        {
            unsafe
            {
                fixed (Int16* addr_ptr = addr)
                {
                    Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantsvEXT(Int32 id, Int16[] addr)
        {
            unsafe
            {
                fixed (Int16* addr_ptr = addr)
                {
                    Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantsvEXT(UInt32 id, ref Int16 addr)
        {
            unsafe
            {
                fixed (Int16* addr_ptr = &addr)
                {
                    Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantsvEXT(Int32 id, ref Int16 addr)
        {
            unsafe
            {
                fixed (Int16* addr_ptr = &addr)
                {
                    Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantivEXT(UInt32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantivEXT((UInt32)id, (Int32*)addr);
            }
        }

        public static 
        void glVariantivEXT(Int32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantivEXT((UInt32)id, (Int32*)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantivEXT(UInt32 id, Int32[] addr)
        {
            unsafe
            {
                fixed (Int32* addr_ptr = addr)
                {
                    Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantivEXT(Int32 id, Int32[] addr)
        {
            unsafe
            {
                fixed (Int32* addr_ptr = addr)
                {
                    Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantivEXT(UInt32 id, ref Int32 addr)
        {
            unsafe
            {
                fixed (Int32* addr_ptr = &addr)
                {
                    Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantivEXT(Int32 id, ref Int32 addr)
        {
            unsafe
            {
                fixed (Int32* addr_ptr = &addr)
                {
                    Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantfvEXT(UInt32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantfvEXT((UInt32)id, (Single*)addr);
            }
        }

        public static 
        void glVariantfvEXT(Int32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantfvEXT((UInt32)id, (Single*)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantfvEXT(UInt32 id, Single[] addr)
        {
            unsafe
            {
                fixed (Single* addr_ptr = addr)
                {
                    Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantfvEXT(Int32 id, Single[] addr)
        {
            unsafe
            {
                fixed (Single* addr_ptr = addr)
                {
                    Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantfvEXT(UInt32 id, ref Single addr)
        {
            unsafe
            {
                fixed (Single* addr_ptr = &addr)
                {
                    Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantfvEXT(Int32 id, ref Single addr)
        {
            unsafe
            {
                fixed (Single* addr_ptr = &addr)
                {
                    Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantdvEXT(UInt32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantdvEXT((UInt32)id, (Double*)addr);
            }
        }

        public static 
        void glVariantdvEXT(Int32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantdvEXT((UInt32)id, (Double*)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantdvEXT(UInt32 id, Double[] addr)
        {
            unsafe
            {
                fixed (Double* addr_ptr = addr)
                {
                    Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantdvEXT(Int32 id, Double[] addr)
        {
            unsafe
            {
                fixed (Double* addr_ptr = addr)
                {
                    Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantdvEXT(UInt32 id, ref Double addr)
        {
            unsafe
            {
                fixed (Double* addr_ptr = &addr)
                {
                    Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantdvEXT(Int32 id, ref Double addr)
        {
            unsafe
            {
                fixed (Double* addr_ptr = &addr)
                {
                    Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantubvEXT(UInt32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr);
            }
        }

        public static 
        void glVariantubvEXT(Int32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantubvEXT(UInt32 id, Byte[] addr)
        {
            unsafe
            {
                fixed (Byte* addr_ptr = addr)
                {
                    Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantubvEXT(Int32 id, Byte[] addr)
        {
            unsafe
            {
                fixed (Byte* addr_ptr = addr)
                {
                    Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantubvEXT(UInt32 id, ref Byte addr)
        {
            unsafe
            {
                fixed (Byte* addr_ptr = &addr)
                {
                    Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantubvEXT(Int32 id, ref Byte addr)
        {
            unsafe
            {
                fixed (Byte* addr_ptr = &addr)
                {
                    Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantusvEXT(UInt32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr);
            }
        }

        public static 
        void glVariantusvEXT(Int32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantusvEXT(UInt32 id, UInt16[] addr)
        {
            unsafe
            {
                fixed (UInt16* addr_ptr = addr)
                {
                    Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantusvEXT(Int32 id, Int16[] addr)
        {
            unsafe
            {
                fixed (Int16* addr_ptr = addr)
                {
                    Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantusvEXT(UInt32 id, ref UInt16 addr)
        {
            unsafe
            {
                fixed (UInt16* addr_ptr = &addr)
                {
                    Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantusvEXT(Int32 id, ref Int16 addr)
        {
            unsafe
            {
                fixed (Int16* addr_ptr = &addr)
                {
                    Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantuivEXT(UInt32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr);
            }
        }

        public static 
        void glVariantuivEXT(Int32 id, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantuivEXT(UInt32 id, UInt32[] addr)
        {
            unsafe
            {
                fixed (UInt32* addr_ptr = addr)
                {
                    Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantuivEXT(Int32 id, Int32[] addr)
        {
            unsafe
            {
                fixed (Int32* addr_ptr = addr)
                {
                    Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantuivEXT(UInt32 id, ref UInt32 addr)
        {
            unsafe
            {
                fixed (UInt32* addr_ptr = &addr)
                {
                    Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
                }
            }
        }

        public static 
        void glVariantuivEXT(Int32 id, ref Int32 addr)
        {
            unsafe
            {
                fixed (Int32* addr_ptr = &addr)
                {
                    Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantPointerEXT(UInt32 id, int type, UInt32 stride, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantPointerEXT((UInt32)id, (int)type, (UInt32)stride, (IntPtr)addr);
            }
        }

        public static 
        void glVariantPointerEXT(Int32 id, int type, Int32 stride, IntPtr addr)
        {
            unsafe
            {
                Delegates.glVariantPointerEXT((UInt32)id, (int)type, (UInt32)stride, (IntPtr)addr);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantPointerEXT(UInt32 id, int type, UInt32 stride, [In, Out] object addr)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVariantPointerEXT((UInt32)id, (int)type, (UInt32)stride, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }
        }

        public static 
        void glVariantPointerEXT(Int32 id, int type, Int32 stride, [In, Out] object addr)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVariantPointerEXT((UInt32)id, (int)type, (UInt32)stride, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glEnableVariantClientStateEXT(UInt32 id)
        {
            Delegates.glEnableVariantClientStateEXT((UInt32)id);
        }

        public static 
        void glEnableVariantClientStateEXT(Int32 id)
        {
            Delegates.glEnableVariantClientStateEXT((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDisableVariantClientStateEXT(UInt32 id)
        {
            Delegates.glDisableVariantClientStateEXT((UInt32)id);
        }

        public static 
        void glDisableVariantClientStateEXT(Int32 id)
        {
            Delegates.glDisableVariantClientStateEXT((UInt32)id);
        }

        public static 
        Int32 glBindLightParameterEXT(int light, int value)
        {
            return Delegates.glBindLightParameterEXT((int)light, (int)value);
        }

        public static 
        Int32 glBindMaterialParameterEXT(int face, int value)
        {
            return Delegates.glBindMaterialParameterEXT((int)face, (int)value);
        }

        public static 
        Int32 glBindTexGenParameterEXT(int unit, int coord, int value)
        {
            return Delegates.glBindTexGenParameterEXT((int)unit, (int)coord, (int)value);
        }

        public static 
        Int32 glBindTextureUnitParameterEXT(int unit, int value)
        {
            return Delegates.glBindTextureUnitParameterEXT((int)unit, (int)value);
        }

        public static 
        Int32 glBindParameterEXT(int value)
        {
            return Delegates.glBindParameterEXT((int)value);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsVariantEnabledEXT(UInt32 id, int cap)
        {
            return Delegates.glIsVariantEnabledEXT((UInt32)id, (int)cap);
        }

        public static 
        Int32 glIsVariantEnabledEXT(Int32 id, int cap)
        {
            return Delegates.glIsVariantEnabledEXT((UInt32)id, (int)cap);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantBooleanvEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetVariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        public static 
        void glGetVariantBooleanvEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetVariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantBooleanvEXT(UInt32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetVariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        public static 
        void glGetVariantBooleanvEXT(Int32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetVariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantBooleanvEXT(UInt32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetVariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetVariantBooleanvEXT(Int32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetVariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantIntegervEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetVariantIntegervEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        public static 
        void glGetVariantIntegervEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetVariantIntegervEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantIntegervEXT(UInt32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetVariantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        public static 
        void glGetVariantIntegervEXT(Int32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetVariantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantIntegervEXT(UInt32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetVariantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetVariantIntegervEXT(Int32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetVariantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantFloatvEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetVariantFloatvEXT((UInt32)id, (int)value, (Single*)data);
            }
        }

        public static 
        void glGetVariantFloatvEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetVariantFloatvEXT((UInt32)id, (int)value, (Single*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantFloatvEXT(UInt32 id, int value, [Out] Single[] data)
        {
            unsafe
            {
                fixed (Single* data_ptr = data)
                {
                    Delegates.glGetVariantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                }
            }
        }

        public static 
        void glGetVariantFloatvEXT(Int32 id, int value, [Out] Single[] data)
        {
            unsafe
            {
                fixed (Single* data_ptr = data)
                {
                    Delegates.glGetVariantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantFloatvEXT(UInt32 id, int value, [Out] out Single data)
        {
            unsafe
            {
                fixed (Single* data_ptr = &data)
                {
                    Delegates.glGetVariantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetVariantFloatvEXT(Int32 id, int value, [Out] out Single data)
        {
            unsafe
            {
                fixed (Single* data_ptr = &data)
                {
                    Delegates.glGetVariantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantPointervEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetVariantPointervEXT((UInt32)id, (int)value, (IntPtr)data);
            }
        }

        public static 
        void glGetVariantPointervEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetVariantPointervEXT((UInt32)id, (int)value, (IntPtr)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantPointervEXT(UInt32 id, int value, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVariantPointervEXT((UInt32)id, (int)value, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        public static 
        void glGetVariantPointervEXT(Int32 id, int value, [In, Out] object data)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVariantPointervEXT((UInt32)id, (int)value, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantBooleanvEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetInvariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        public static 
        void glGetInvariantBooleanvEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetInvariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantBooleanvEXT(UInt32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetInvariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        public static 
        void glGetInvariantBooleanvEXT(Int32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetInvariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantBooleanvEXT(UInt32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetInvariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetInvariantBooleanvEXT(Int32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetInvariantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantIntegervEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetInvariantIntegervEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        public static 
        void glGetInvariantIntegervEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetInvariantIntegervEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantIntegervEXT(UInt32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetInvariantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        public static 
        void glGetInvariantIntegervEXT(Int32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetInvariantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantIntegervEXT(UInt32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetInvariantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetInvariantIntegervEXT(Int32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetInvariantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantFloatvEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetInvariantFloatvEXT((UInt32)id, (int)value, (Single*)data);
            }
        }

        public static 
        void glGetInvariantFloatvEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetInvariantFloatvEXT((UInt32)id, (int)value, (Single*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantFloatvEXT(UInt32 id, int value, [Out] Single[] data)
        {
            unsafe
            {
                fixed (Single* data_ptr = data)
                {
                    Delegates.glGetInvariantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                }
            }
        }

        public static 
        void glGetInvariantFloatvEXT(Int32 id, int value, [Out] Single[] data)
        {
            unsafe
            {
                fixed (Single* data_ptr = data)
                {
                    Delegates.glGetInvariantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetInvariantFloatvEXT(UInt32 id, int value, [Out] out Single data)
        {
            unsafe
            {
                fixed (Single* data_ptr = &data)
                {
                    Delegates.glGetInvariantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetInvariantFloatvEXT(Int32 id, int value, [Out] out Single data)
        {
            unsafe
            {
                fixed (Single* data_ptr = &data)
                {
                    Delegates.glGetInvariantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantBooleanvEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        public static 
        void glGetLocalConstantBooleanvEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantBooleanvEXT(UInt32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        public static 
        void glGetLocalConstantBooleanvEXT(Int32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantBooleanvEXT(UInt32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetLocalConstantBooleanvEXT(Int32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantIntegervEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        public static 
        void glGetLocalConstantIntegervEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (int)value, (Int32*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantIntegervEXT(UInt32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        public static 
        void glGetLocalConstantIntegervEXT(Int32 id, int value, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantIntegervEXT(UInt32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetLocalConstantIntegervEXT(Int32 id, int value, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (int)value, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantFloatvEXT(UInt32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (int)value, (Single*)data);
            }
        }

        public static 
        void glGetLocalConstantFloatvEXT(Int32 id, int value, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (int)value, (Single*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantFloatvEXT(UInt32 id, int value, [Out] Single[] data)
        {
            unsafe
            {
                fixed (Single* data_ptr = data)
                {
                    Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                }
            }
        }

        public static 
        void glGetLocalConstantFloatvEXT(Int32 id, int value, [Out] Single[] data)
        {
            unsafe
            {
                fixed (Single* data_ptr = data)
                {
                    Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetLocalConstantFloatvEXT(UInt32 id, int value, [Out] out Single data)
        {
            unsafe
            {
                fixed (Single* data_ptr = &data)
                {
                    Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetLocalConstantFloatvEXT(Int32 id, int value, [Out] out Single data)
        {
            unsafe
            {
                fixed (Single* data_ptr = &data)
                {
                    Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (int)value, (Single*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glActiveStencilFaceEXT(int face)
        {
            Delegates.glActiveStencilFaceEXT((int)face);
        }

        public static 
        void glDepthBoundsEXT(Double zmin, Double zmax)
        {
            Delegates.glDepthBoundsEXT((Double)zmin, (Double)zmax);
        }

        public static 
        void glBlendEquationSeparateEXT(int modeRGB, int modeAlpha)
        {
            Delegates.glBlendEquationSeparateEXT((int)modeRGB, (int)modeAlpha);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsRenderbufferEXT(UInt32 renderbuffer)
        {
            return Delegates.glIsRenderbufferEXT((UInt32)renderbuffer);
        }

        public static 
        Int32 glIsRenderbufferEXT(Int32 renderbuffer)
        {
            return Delegates.glIsRenderbufferEXT((UInt32)renderbuffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindRenderbufferEXT(int target, UInt32 renderbuffer)
        {
            Delegates.glBindRenderbufferEXT((int)target, (UInt32)renderbuffer);
        }

        public static 
        void glBindRenderbufferEXT(int target, Int32 renderbuffer)
        {
            Delegates.glBindRenderbufferEXT((int)target, (UInt32)renderbuffer);
        }

        public static 
        void glDeleteRenderbuffersEXT(Int32 n, IntPtr renderbuffers)
        {
            unsafe
            {
                Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteRenderbuffersEXT(Int32 n, UInt32[] renderbuffers)
        {
            unsafe
            {
                fixed (UInt32* renderbuffers_ptr = renderbuffers)
                {
                    Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                }
            }
        }

        public static 
        void glDeleteRenderbuffersEXT(Int32 n, Int32[] renderbuffers)
        {
            unsafe
            {
                fixed (Int32* renderbuffers_ptr = renderbuffers)
                {
                    Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteRenderbuffersEXT(Int32 n, ref UInt32 renderbuffers)
        {
            unsafe
            {
                fixed (UInt32* renderbuffers_ptr = &renderbuffers)
                {
                    Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                }
            }
        }

        public static 
        void glDeleteRenderbuffersEXT(Int32 n, ref Int32 renderbuffers)
        {
            unsafe
            {
                fixed (Int32* renderbuffers_ptr = &renderbuffers)
                {
                    Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                }
            }
        }

        public static 
        void glGenRenderbuffersEXT(Int32 n, [Out] IntPtr renderbuffers)
        {
            unsafe
            {
                Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenRenderbuffersEXT(Int32 n, [Out] UInt32[] renderbuffers)
        {
            unsafe
            {
                fixed (UInt32* renderbuffers_ptr = renderbuffers)
                {
                    Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                }
            }
        }

        public static 
        void glGenRenderbuffersEXT(Int32 n, [Out] Int32[] renderbuffers)
        {
            unsafe
            {
                fixed (Int32* renderbuffers_ptr = renderbuffers)
                {
                    Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenRenderbuffersEXT(Int32 n, [Out] out UInt32 renderbuffers)
        {
            unsafe
            {
                fixed (UInt32* renderbuffers_ptr = &renderbuffers)
                {
                    Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                    renderbuffers = *renderbuffers_ptr;
                }
            }
        }

        public static 
        void glGenRenderbuffersEXT(Int32 n, [Out] out Int32 renderbuffers)
        {
            unsafe
            {
                fixed (Int32* renderbuffers_ptr = &renderbuffers)
                {
                    Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                    renderbuffers = *renderbuffers_ptr;
                }
            }
        }

        public static 
        void glRenderbufferStorageEXT(int target, int internalformat, Int32 width, Int32 height)
        {
            Delegates.glRenderbufferStorageEXT((int)target, (int)internalformat, (Int32)width, (Int32)height);
        }

        public static 
        void glGetRenderbufferParameterivEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetRenderbufferParameterivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetRenderbufferParameterivEXT(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetRenderbufferParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetRenderbufferParameterivEXT(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetRenderbufferParameterivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsFramebufferEXT(UInt32 framebuffer)
        {
            return Delegates.glIsFramebufferEXT((UInt32)framebuffer);
        }

        public static 
        Int32 glIsFramebufferEXT(Int32 framebuffer)
        {
            return Delegates.glIsFramebufferEXT((UInt32)framebuffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindFramebufferEXT(int target, UInt32 framebuffer)
        {
            Delegates.glBindFramebufferEXT((int)target, (UInt32)framebuffer);
        }

        public static 
        void glBindFramebufferEXT(int target, Int32 framebuffer)
        {
            Delegates.glBindFramebufferEXT((int)target, (UInt32)framebuffer);
        }

        public static 
        void glDeleteFramebuffersEXT(Int32 n, IntPtr framebuffers)
        {
            unsafe
            {
                Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteFramebuffersEXT(Int32 n, UInt32[] framebuffers)
        {
            unsafe
            {
                fixed (UInt32* framebuffers_ptr = framebuffers)
                {
                    Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                }
            }
        }

        public static 
        void glDeleteFramebuffersEXT(Int32 n, Int32[] framebuffers)
        {
            unsafe
            {
                fixed (Int32* framebuffers_ptr = framebuffers)
                {
                    Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteFramebuffersEXT(Int32 n, ref UInt32 framebuffers)
        {
            unsafe
            {
                fixed (UInt32* framebuffers_ptr = &framebuffers)
                {
                    Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                }
            }
        }

        public static 
        void glDeleteFramebuffersEXT(Int32 n, ref Int32 framebuffers)
        {
            unsafe
            {
                fixed (Int32* framebuffers_ptr = &framebuffers)
                {
                    Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                }
            }
        }

        public static 
        void glGenFramebuffersEXT(Int32 n, [Out] IntPtr framebuffers)
        {
            unsafe
            {
                Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenFramebuffersEXT(Int32 n, [Out] UInt32[] framebuffers)
        {
            unsafe
            {
                fixed (UInt32* framebuffers_ptr = framebuffers)
                {
                    Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                }
            }
        }

        public static 
        void glGenFramebuffersEXT(Int32 n, [Out] Int32[] framebuffers)
        {
            unsafe
            {
                fixed (Int32* framebuffers_ptr = framebuffers)
                {
                    Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenFramebuffersEXT(Int32 n, [Out] out UInt32 framebuffers)
        {
            unsafe
            {
                fixed (UInt32* framebuffers_ptr = &framebuffers)
                {
                    Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                    framebuffers = *framebuffers_ptr;
                }
            }
        }

        public static 
        void glGenFramebuffersEXT(Int32 n, [Out] out Int32 framebuffers)
        {
            unsafe
            {
                fixed (Int32* framebuffers_ptr = &framebuffers)
                {
                    Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                    framebuffers = *framebuffers_ptr;
                }
            }
        }

        public static 
        int glCheckFramebufferStatusEXT(int target)
        {
            return Delegates.glCheckFramebufferStatusEXT((int)target);
        }

        [System.CLSCompliant(false)]
        public static 
        void glFramebufferTexture1DEXT(int target, int attachment, int textarget, UInt32 texture, Int32 level)
        {
            Delegates.glFramebufferTexture1DEXT((int)target, (int)attachment, (int)textarget, (UInt32)texture, (Int32)level);
        }

        public static 
        void glFramebufferTexture1DEXT(int target, int attachment, int textarget, Int32 texture, Int32 level)
        {
            Delegates.glFramebufferTexture1DEXT((int)target, (int)attachment, (int)textarget, (UInt32)texture, (Int32)level);
        }

        [System.CLSCompliant(false)]
        public static 
        void glFramebufferTexture2DEXT(int target, int attachment, int textarget, UInt32 texture, Int32 level)
        {
            Delegates.glFramebufferTexture2DEXT((int)target, (int)attachment, (int)textarget, (UInt32)texture, (Int32)level);
        }

        public static 
        void glFramebufferTexture2DEXT(int target, int attachment, int textarget, Int32 texture, Int32 level)
        {
            Delegates.glFramebufferTexture2DEXT((int)target, (int)attachment, (int)textarget, (UInt32)texture, (Int32)level);
        }

        [System.CLSCompliant(false)]
        public static 
        void glFramebufferTexture3DEXT(int target, int attachment, int textarget, UInt32 texture, Int32 level, Int32 zoffset)
        {
            Delegates.glFramebufferTexture3DEXT((int)target, (int)attachment, (int)textarget, (UInt32)texture, (Int32)level, (Int32)zoffset);
        }

        public static 
        void glFramebufferTexture3DEXT(int target, int attachment, int textarget, Int32 texture, Int32 level, Int32 zoffset)
        {
            Delegates.glFramebufferTexture3DEXT((int)target, (int)attachment, (int)textarget, (UInt32)texture, (Int32)level, (Int32)zoffset);
        }

        [System.CLSCompliant(false)]
        public static 
        void glFramebufferRenderbufferEXT(int target, int attachment, int renderbuffertarget, UInt32 renderbuffer)
        {
            Delegates.glFramebufferRenderbufferEXT((int)target, (int)attachment, (int)renderbuffertarget, (UInt32)renderbuffer);
        }

        public static 
        void glFramebufferRenderbufferEXT(int target, int attachment, int renderbuffertarget, Int32 renderbuffer)
        {
            Delegates.glFramebufferRenderbufferEXT((int)target, (int)attachment, (int)renderbuffertarget, (UInt32)renderbuffer);
        }

        public static 
        void glGetFramebufferAttachmentParameterivEXT(int target, int attachment, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFramebufferAttachmentParameterivEXT((int)target, (int)attachment, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetFramebufferAttachmentParameterivEXT(int target, int attachment, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetFramebufferAttachmentParameterivEXT((int)target, (int)attachment, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFramebufferAttachmentParameterivEXT(int target, int attachment, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetFramebufferAttachmentParameterivEXT((int)target, (int)attachment, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGenerateMipmapEXT(int target)
        {
            Delegates.glGenerateMipmapEXT((int)target);
        }

        [System.CLSCompliant(false)]
        public static 
        void glStencilClearTagEXT(Int32 stencilTagBits, UInt32 stencilClearTag)
        {
            Delegates.glStencilClearTagEXT((Int32)stencilTagBits, (UInt32)stencilClearTag);
        }

        public static 
        void glStencilClearTagEXT(Int32 stencilTagBits, Int32 stencilClearTag)
        {
            Delegates.glStencilClearTagEXT((Int32)stencilTagBits, (UInt32)stencilClearTag);
        }

        public static 
        void glBlitFramebufferEXT(Int32 srcX0, Int32 srcY0, Int32 srcX1, Int32 srcY1, Int32 dstX0, Int32 dstY0, Int32 dstX1, Int32 dstY1, int mask, int filter)
        {
            Delegates.glBlitFramebufferEXT((Int32)srcX0, (Int32)srcY0, (Int32)srcX1, (Int32)srcY1, (Int32)dstX0, (Int32)dstY0, (Int32)dstX1, (Int32)dstY1, (int)mask, (int)filter);
        }

        public static 
        void glRenderbufferStorageMultisampleEXT(int target, Int32 samples, int internalformat, Int32 width, Int32 height)
        {
            Delegates.glRenderbufferStorageMultisampleEXT((int)target, (Int32)samples, (int)internalformat, (Int32)width, (Int32)height);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjecti64vEXT(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjecti64vEXT((UInt32)id, (int)pname, (Int64*)@params);
            }
        }

        public static 
        void glGetQueryObjecti64vEXT(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjecti64vEXT((UInt32)id, (int)pname, (Int64*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjecti64vEXT(UInt32 id, int pname, [Out] Int64[] @params)
        {
            unsafe
            {
                fixed (Int64* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjecti64vEXT((UInt32)id, (int)pname, (Int64*)@params_ptr);
                }
            }
        }

        public static 
        void glGetQueryObjecti64vEXT(Int32 id, int pname, [Out] Int64[] @params)
        {
            unsafe
            {
                fixed (Int64* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjecti64vEXT((UInt32)id, (int)pname, (Int64*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjecti64vEXT(UInt32 id, int pname, [Out] out Int64 @params)
        {
            unsafe
            {
                fixed (Int64* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjecti64vEXT((UInt32)id, (int)pname, (Int64*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetQueryObjecti64vEXT(Int32 id, int pname, [Out] out Int64 @params)
        {
            unsafe
            {
                fixed (Int64* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjecti64vEXT((UInt32)id, (int)pname, (Int64*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectui64vEXT(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectui64vEXT((UInt32)id, (int)pname, (UInt64*)@params);
            }
        }

        public static 
        void glGetQueryObjectui64vEXT(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetQueryObjectui64vEXT((UInt32)id, (int)pname, (UInt64*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectui64vEXT(UInt32 id, int pname, [Out] UInt64[] @params)
        {
            unsafe
            {
                fixed (UInt64* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectui64vEXT((UInt32)id, (int)pname, (UInt64*)@params_ptr);
                }
            }
        }

        public static 
        void glGetQueryObjectui64vEXT(Int32 id, int pname, [Out] Int64[] @params)
        {
            unsafe
            {
                fixed (Int64* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectui64vEXT((UInt32)id, (int)pname, (UInt64*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetQueryObjectui64vEXT(UInt32 id, int pname, [Out] out UInt64 @params)
        {
            unsafe
            {
                fixed (UInt64* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectui64vEXT((UInt32)id, (int)pname, (UInt64*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetQueryObjectui64vEXT(Int32 id, int pname, [Out] out Int64 @params)
        {
            unsafe
            {
                fixed (Int64* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectui64vEXT((UInt32)id, (int)pname, (UInt64*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameters4fvEXT(int target, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params);
            }
        }

        public static 
        void glProgramEnvParameters4fvEXT(int target, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameters4fvEXT(int target, UInt32 index, Int32 count, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameters4fvEXT(int target, Int32 index, Int32 count, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameters4fvEXT(int target, UInt32 index, Int32 count, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameters4fvEXT(int target, Int32 index, Int32 count, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameters4fvEXT(int target, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params);
            }
        }

        public static 
        void glProgramLocalParameters4fvEXT(int target, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameters4fvEXT(int target, UInt32 index, Int32 count, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameters4fvEXT(int target, Int32 index, Int32 count, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameters4fvEXT(int target, UInt32 index, Int32 count, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameters4fvEXT(int target, Int32 index, Int32 count, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameters4fvEXT((int)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glFramebufferTextureEXT(int target, int attachment, UInt32 texture, Int32 level)
        {
            Delegates.glFramebufferTextureEXT((int)target, (int)attachment, (UInt32)texture, (Int32)level);
        }

        public static 
        void glFramebufferTextureEXT(int target, int attachment, Int32 texture, Int32 level)
        {
            Delegates.glFramebufferTextureEXT((int)target, (int)attachment, (UInt32)texture, (Int32)level);
        }

        [System.CLSCompliant(false)]
        public static 
        void glFramebufferTextureLayerEXT(int target, int attachment, UInt32 texture, Int32 level, Int32 layer)
        {
            Delegates.glFramebufferTextureLayerEXT((int)target, (int)attachment, (UInt32)texture, (Int32)level, (Int32)layer);
        }

        public static 
        void glFramebufferTextureLayerEXT(int target, int attachment, Int32 texture, Int32 level, Int32 layer)
        {
            Delegates.glFramebufferTextureLayerEXT((int)target, (int)attachment, (UInt32)texture, (Int32)level, (Int32)layer);
        }

        [System.CLSCompliant(false)]
        public static 
        void glFramebufferTextureFaceEXT(int target, int attachment, UInt32 texture, Int32 level, int face)
        {
            Delegates.glFramebufferTextureFaceEXT((int)target, (int)attachment, (UInt32)texture, (Int32)level, (int)face);
        }

        public static 
        void glFramebufferTextureFaceEXT(int target, int attachment, Int32 texture, Int32 level, int face)
        {
            Delegates.glFramebufferTextureFaceEXT((int)target, (int)attachment, (UInt32)texture, (Int32)level, (int)face);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameteriEXT(UInt32 program, int pname, Int32 value)
        {
            Delegates.glProgramParameteriEXT((UInt32)program, (int)pname, (Int32)value);
        }

        public static 
        void glProgramParameteriEXT(Int32 program, int pname, Int32 value)
        {
            Delegates.glProgramParameteriEXT((UInt32)program, (int)pname, (Int32)value);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI1iEXT(UInt32 index, Int32 x)
        {
            Delegates.glVertexAttribI1iEXT((UInt32)index, (Int32)x);
        }

        public static 
        void glVertexAttribI1iEXT(Int32 index, Int32 x)
        {
            Delegates.glVertexAttribI1iEXT((UInt32)index, (Int32)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI2iEXT(UInt32 index, Int32 x, Int32 y)
        {
            Delegates.glVertexAttribI2iEXT((UInt32)index, (Int32)x, (Int32)y);
        }

        public static 
        void glVertexAttribI2iEXT(Int32 index, Int32 x, Int32 y)
        {
            Delegates.glVertexAttribI2iEXT((UInt32)index, (Int32)x, (Int32)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI3iEXT(UInt32 index, Int32 x, Int32 y, Int32 z)
        {
            Delegates.glVertexAttribI3iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void glVertexAttribI3iEXT(Int32 index, Int32 x, Int32 y, Int32 z)
        {
            Delegates.glVertexAttribI3iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4iEXT(UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glVertexAttribI4iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void glVertexAttribI4iEXT(Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glVertexAttribI4iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI1uiEXT(UInt32 index, UInt32 x)
        {
            Delegates.glVertexAttribI1uiEXT((UInt32)index, (UInt32)x);
        }

        public static 
        void glVertexAttribI1uiEXT(Int32 index, Int32 x)
        {
            Delegates.glVertexAttribI1uiEXT((UInt32)index, (UInt32)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI2uiEXT(UInt32 index, UInt32 x, UInt32 y)
        {
            Delegates.glVertexAttribI2uiEXT((UInt32)index, (UInt32)x, (UInt32)y);
        }

        public static 
        void glVertexAttribI2uiEXT(Int32 index, Int32 x, Int32 y)
        {
            Delegates.glVertexAttribI2uiEXT((UInt32)index, (UInt32)x, (UInt32)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI3uiEXT(UInt32 index, UInt32 x, UInt32 y, UInt32 z)
        {
            Delegates.glVertexAttribI3uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z);
        }

        public static 
        void glVertexAttribI3uiEXT(Int32 index, Int32 x, Int32 y, Int32 z)
        {
            Delegates.glVertexAttribI3uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4uiEXT(UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
        {
            Delegates.glVertexAttribI4uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
        }

        public static 
        void glVertexAttribI4uiEXT(Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glVertexAttribI4uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI1ivEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v);
            }
        }

        public static 
        void glVertexAttribI1ivEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI1ivEXT(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI1ivEXT(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI1ivEXT(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI1ivEXT(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI2ivEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v);
            }
        }

        public static 
        void glVertexAttribI2ivEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI2ivEXT(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI2ivEXT(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI2ivEXT(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI2ivEXT(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI3ivEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v);
            }
        }

        public static 
        void glVertexAttribI3ivEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI3ivEXT(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI3ivEXT(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI3ivEXT(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI3ivEXT(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4ivEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v);
            }
        }

        public static 
        void glVertexAttribI4ivEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4ivEXT(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4ivEXT(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4ivEXT(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4ivEXT(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI1uivEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v);
            }
        }

        public static 
        void glVertexAttribI1uivEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI1uivEXT(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI1uivEXT(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI1uivEXT(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI1uivEXT(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI2uivEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v);
            }
        }

        public static 
        void glVertexAttribI2uivEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI2uivEXT(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI2uivEXT(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI2uivEXT(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI2uivEXT(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI3uivEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v);
            }
        }

        public static 
        void glVertexAttribI3uivEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI3uivEXT(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI3uivEXT(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI3uivEXT(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI3uivEXT(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4uivEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v);
            }
        }

        public static 
        void glVertexAttribI4uivEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4uivEXT(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4uivEXT(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4uivEXT(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4uivEXT(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4bvEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v);
            }
        }

        public static 
        void glVertexAttribI4bvEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4bvEXT(UInt32 index, SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4bvEXT(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4bvEXT(UInt32 index, ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4bvEXT(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4svEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttribI4svEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4svEXT(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4svEXT(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4svEXT(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4svEXT(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4ubvEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v);
            }
        }

        public static 
        void glVertexAttribI4ubvEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4ubvEXT(UInt32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4ubvEXT(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4ubvEXT(UInt32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4ubvEXT(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4usvEXT(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttribI4usvEXT(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4usvEXT(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4usvEXT(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribI4usvEXT(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribI4usvEXT(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribIPointerEXT(UInt32 index, Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexAttribIPointerEXT(Int32 index, Int32 size, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribIPointerEXT(UInt32 index, Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexAttribIPointerEXT(Int32 index, Int32 size, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribIivEXT(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribIivEXT((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetVertexAttribIivEXT(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribIivEXT((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribIivEXT(UInt32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribIivEXT((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribIivEXT(Int32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribIivEXT((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribIivEXT(UInt32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribIivEXT((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribIivEXT(Int32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribIivEXT((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribIuivEXT(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribIuivEXT((UInt32)index, (int)pname, (UInt32*)@params);
            }
        }

        public static 
        void glGetVertexAttribIuivEXT(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribIuivEXT((UInt32)index, (int)pname, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribIuivEXT(UInt32 index, int pname, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribIuivEXT((UInt32)index, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribIuivEXT(Int32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribIuivEXT((UInt32)index, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribIuivEXT(UInt32 index, int pname, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribIuivEXT((UInt32)index, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribIuivEXT(Int32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribIuivEXT((UInt32)index, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformuivEXT(UInt32 program, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params);
            }
        }

        public static 
        void glGetUniformuivEXT(Int32 program, Int32 location, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformuivEXT(UInt32 program, Int32 location, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetUniformuivEXT(Int32 program, Int32 location, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetUniformuivEXT(UInt32 program, Int32 location, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetUniformuivEXT(Int32 program, Int32 location, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindFragDataLocationEXT(UInt32 program, UInt32 color, System.String name)
        {
            Delegates.glBindFragDataLocationEXT((UInt32)program, (UInt32)color, (System.String)name);
        }

        public static 
        void glBindFragDataLocationEXT(Int32 program, Int32 color, System.String name)
        {
            Delegates.glBindFragDataLocationEXT((UInt32)program, (UInt32)color, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGetFragDataLocationEXT(UInt32 program, System.String name)
        {
            return Delegates.glGetFragDataLocationEXT((UInt32)program, (System.String)name);
        }

        public static 
        Int32 glGetFragDataLocationEXT(Int32 program, System.String name)
        {
            return Delegates.glGetFragDataLocationEXT((UInt32)program, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform1uiEXT(Int32 location, UInt32 v0)
        {
            Delegates.glUniform1uiEXT((Int32)location, (UInt32)v0);
        }

        public static 
        void glUniform1uiEXT(Int32 location, Int32 v0)
        {
            Delegates.glUniform1uiEXT((Int32)location, (UInt32)v0);
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform2uiEXT(Int32 location, UInt32 v0, UInt32 v1)
        {
            Delegates.glUniform2uiEXT((Int32)location, (UInt32)v0, (UInt32)v1);
        }

        public static 
        void glUniform2uiEXT(Int32 location, Int32 v0, Int32 v1)
        {
            Delegates.glUniform2uiEXT((Int32)location, (UInt32)v0, (UInt32)v1);
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform3uiEXT(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2)
        {
            Delegates.glUniform3uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2);
        }

        public static 
        void glUniform3uiEXT(Int32 location, Int32 v0, Int32 v1, Int32 v2)
        {
            Delegates.glUniform3uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2);
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform4uiEXT(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2, UInt32 v3)
        {
            Delegates.glUniform4uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2, (UInt32)v3);
        }

        public static 
        void glUniform4uiEXT(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
        {
            Delegates.glUniform4uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2, (UInt32)v3);
        }

        public static 
        void glUniform1uivEXT(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform1uivEXT(Int32 location, Int32 count, UInt32[] value)
        {
            unsafe
            {
                fixed (UInt32* value_ptr = value)
                {
                    Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform1uivEXT(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform1uivEXT(Int32 location, Int32 count, ref UInt32 value)
        {
            unsafe
            {
                fixed (UInt32* value_ptr = &value)
                {
                    Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform1uivEXT(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2uivEXT(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform2uivEXT(Int32 location, Int32 count, UInt32[] value)
        {
            unsafe
            {
                fixed (UInt32* value_ptr = value)
                {
                    Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2uivEXT(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform2uivEXT(Int32 location, Int32 count, ref UInt32 value)
        {
            unsafe
            {
                fixed (UInt32* value_ptr = &value)
                {
                    Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform2uivEXT(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3uivEXT(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform3uivEXT(Int32 location, Int32 count, UInt32[] value)
        {
            unsafe
            {
                fixed (UInt32* value_ptr = value)
                {
                    Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3uivEXT(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform3uivEXT(Int32 location, Int32 count, ref UInt32 value)
        {
            unsafe
            {
                fixed (UInt32* value_ptr = &value)
                {
                    Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform3uivEXT(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4uivEXT(Int32 location, Int32 count, IntPtr value)
        {
            unsafe
            {
                Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform4uivEXT(Int32 location, Int32 count, UInt32[] value)
        {
            unsafe
            {
                fixed (UInt32* value_ptr = value)
                {
                    Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4uivEXT(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniform4uivEXT(Int32 location, Int32 count, ref UInt32 value)
        {
            unsafe
            {
                fixed (UInt32* value_ptr = &value)
                {
                    Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glUniform4uivEXT(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                }
            }
        }

        public static 
        void glDrawArraysInstancedEXT(int mode, Int32 start, Int32 count, Int32 primcount)
        {
            Delegates.glDrawArraysInstancedEXT((int)mode, (Int32)start, (Int32)count, (Int32)primcount);
        }

        public static 
        void glDrawElementsInstancedEXT(int mode, Int32 count, int type, IntPtr indices, Int32 primcount)
        {
            unsafe
            {
                Delegates.glDrawElementsInstancedEXT((int)mode, (Int32)count, (int)type, (IntPtr)indices, (Int32)primcount);
            }
        }

        public static 
        void glDrawElementsInstancedEXT(int mode, Int32 count, int type, [In, Out] object indices, Int32 primcount)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawElementsInstancedEXT((int)mode, (Int32)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexBufferEXT(int target, int internalformat, UInt32 buffer)
        {
            Delegates.glTexBufferEXT((int)target, (int)internalformat, (UInt32)buffer);
        }

        public static 
        void glTexBufferEXT(int target, int internalformat, Int32 buffer)
        {
            Delegates.glTexBufferEXT((int)target, (int)internalformat, (UInt32)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void glColorMaskIndexedEXT(UInt32 index, Int32 r, Int32 g, Int32 b, Int32 a)
        {
            Delegates.glColorMaskIndexedEXT((UInt32)index, (Int32)r, (Int32)g, (Int32)b, (Int32)a);
        }

        public static 
        void glColorMaskIndexedEXT(Int32 index, Int32 r, Int32 g, Int32 b, Int32 a)
        {
            Delegates.glColorMaskIndexedEXT((UInt32)index, (Int32)r, (Int32)g, (Int32)b, (Int32)a);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetBooleanIndexedvEXT(int target, UInt32 index, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetBooleanIndexedvEXT((int)target, (UInt32)index, (Int32*)data);
            }
        }

        public static 
        void glGetBooleanIndexedvEXT(int target, Int32 index, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetBooleanIndexedvEXT((int)target, (UInt32)index, (Int32*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetBooleanIndexedvEXT(int target, UInt32 index, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetBooleanIndexedvEXT((int)target, (UInt32)index, (Int32*)data_ptr);
                }
            }
        }

        public static 
        void glGetBooleanIndexedvEXT(int target, Int32 index, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetBooleanIndexedvEXT((int)target, (UInt32)index, (Int32*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetBooleanIndexedvEXT(int target, UInt32 index, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetBooleanIndexedvEXT((int)target, (UInt32)index, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetBooleanIndexedvEXT(int target, Int32 index, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetBooleanIndexedvEXT((int)target, (UInt32)index, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetIntegerIndexedvEXT(int target, UInt32 index, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetIntegerIndexedvEXT((int)target, (UInt32)index, (Int32*)data);
            }
        }

        public static 
        void glGetIntegerIndexedvEXT(int target, Int32 index, [Out] IntPtr data)
        {
            unsafe
            {
                Delegates.glGetIntegerIndexedvEXT((int)target, (UInt32)index, (Int32*)data);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetIntegerIndexedvEXT(int target, UInt32 index, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetIntegerIndexedvEXT((int)target, (UInt32)index, (Int32*)data_ptr);
                }
            }
        }

        public static 
        void glGetIntegerIndexedvEXT(int target, Int32 index, [Out] Int32[] data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = data)
                {
                    Delegates.glGetIntegerIndexedvEXT((int)target, (UInt32)index, (Int32*)data_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetIntegerIndexedvEXT(int target, UInt32 index, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetIntegerIndexedvEXT((int)target, (UInt32)index, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        public static 
        void glGetIntegerIndexedvEXT(int target, Int32 index, [Out] out Int32 data)
        {
            unsafe
            {
                fixed (Int32* data_ptr = &data)
                {
                    Delegates.glGetIntegerIndexedvEXT((int)target, (UInt32)index, (Int32*)data_ptr);
                    data = *data_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glEnableIndexedEXT(int target, UInt32 index)
        {
            Delegates.glEnableIndexedEXT((int)target, (UInt32)index);
        }

        public static 
        void glEnableIndexedEXT(int target, Int32 index)
        {
            Delegates.glEnableIndexedEXT((int)target, (UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDisableIndexedEXT(int target, UInt32 index)
        {
            Delegates.glDisableIndexedEXT((int)target, (UInt32)index);
        }

        public static 
        void glDisableIndexedEXT(int target, Int32 index)
        {
            Delegates.glDisableIndexedEXT((int)target, (UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsEnabledIndexedEXT(int target, UInt32 index)
        {
            return Delegates.glIsEnabledIndexedEXT((int)target, (UInt32)index);
        }

        public static 
        Int32 glIsEnabledIndexedEXT(int target, Int32 index)
        {
            return Delegates.glIsEnabledIndexedEXT((int)target, (UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        void glUniformBufferEXT(UInt32 program, Int32 location, UInt32 buffer)
        {
            Delegates.glUniformBufferEXT((UInt32)program, (Int32)location, (UInt32)buffer);
        }

        public static 
        void glUniformBufferEXT(Int32 program, Int32 location, Int32 buffer)
        {
            Delegates.glUniformBufferEXT((UInt32)program, (Int32)location, (UInt32)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGetUniformBufferSizeEXT(UInt32 program, Int32 location)
        {
            return Delegates.glGetUniformBufferSizeEXT((UInt32)program, (Int32)location);
        }

        public static 
        Int32 glGetUniformBufferSizeEXT(Int32 program, Int32 location)
        {
            return Delegates.glGetUniformBufferSizeEXT((UInt32)program, (Int32)location);
        }

        [System.CLSCompliant(false)]
        public static 
        IntPtr glGetUniformOffsetEXT(UInt32 program, Int32 location)
        {
            return Delegates.glGetUniformOffsetEXT((UInt32)program, (Int32)location);
        }

        public static 
        IntPtr glGetUniformOffsetEXT(Int32 program, Int32 location)
        {
            return Delegates.glGetUniformOffsetEXT((UInt32)program, (Int32)location);
        }

        public static 
        void glTexParameterIivEXT(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexParameterIivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glTexParameterIivEXT(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glTexParameterIivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexParameterIivEXT(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glTexParameterIivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexParameterIuivEXT(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexParameterIuivEXT(int target, int pname, UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexParameterIuivEXT(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexParameterIuivEXT(int target, int pname, ref UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glTexParameterIuivEXT(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexParameterIivEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexParameterIivEXT((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetTexParameterIivEXT(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexParameterIivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexParameterIivEXT(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameterIivEXT((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexParameterIuivEXT(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetTexParameterIuivEXT(int target, int pname, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTexParameterIuivEXT(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetTexParameterIuivEXT(int target, int pname, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTexParameterIuivEXT(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameterIuivEXT((int)target, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glClearColorIiEXT(Int32 red, Int32 green, Int32 blue, Int32 alpha)
        {
            Delegates.glClearColorIiEXT((Int32)red, (Int32)green, (Int32)blue, (Int32)alpha);
        }

        [System.CLSCompliant(false)]
        public static 
        void glClearColorIuiEXT(UInt32 red, UInt32 green, UInt32 blue, UInt32 alpha)
        {
            Delegates.glClearColorIuiEXT((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
        }

        public static 
        void glClearColorIuiEXT(Int32 red, Int32 green, Int32 blue, Int32 alpha)
        {
            Delegates.glClearColorIuiEXT((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
        }

        public static 
        void glGetTexFilterFuncSGIS(int target, int filter, [Out] IntPtr weights)
        {
            unsafe
            {
                Delegates.glGetTexFilterFuncSGIS((int)target, (int)filter, (Single*)weights);
            }
        }

        public static 
        void glGetTexFilterFuncSGIS(int target, int filter, [Out] Single[] weights)
        {
            unsafe
            {
                fixed (Single* weights_ptr = weights)
                {
                    Delegates.glGetTexFilterFuncSGIS((int)target, (int)filter, (Single*)weights_ptr);
                }
            }
        }

        public static 
        void glGetTexFilterFuncSGIS(int target, int filter, [Out] out Single weights)
        {
            unsafe
            {
                fixed (Single* weights_ptr = &weights)
                {
                    Delegates.glGetTexFilterFuncSGIS((int)target, (int)filter, (Single*)weights_ptr);
                    weights = *weights_ptr;
                }
            }
        }

        public static 
        void glTexFilterFuncSGIS(int target, int filter, Int32 n, IntPtr weights)
        {
            unsafe
            {
                Delegates.glTexFilterFuncSGIS((int)target, (int)filter, (Int32)n, (Single*)weights);
            }
        }

        public static 
        void glTexFilterFuncSGIS(int target, int filter, Int32 n, Single[] weights)
        {
            unsafe
            {
                fixed (Single* weights_ptr = weights)
                {
                    Delegates.glTexFilterFuncSGIS((int)target, (int)filter, (Int32)n, (Single*)weights_ptr);
                }
            }
        }

        public static 
        void glTexFilterFuncSGIS(int target, int filter, Int32 n, ref Single weights)
        {
            unsafe
            {
                fixed (Single* weights_ptr = &weights)
                {
                    Delegates.glTexFilterFuncSGIS((int)target, (int)filter, (Int32)n, (Single*)weights_ptr);
                }
            }
        }

        public static 
        void glPixelTexGenParameteriSGIS(int pname, Int32 param)
        {
            Delegates.glPixelTexGenParameteriSGIS((int)pname, (Int32)param);
        }

        public static 
        void glPixelTexGenParameterivSGIS(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPixelTexGenParameterivSGIS((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glPixelTexGenParameterivSGIS(int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glPixelTexGenParameterivSGIS((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glPixelTexGenParameterivSGIS(int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glPixelTexGenParameterivSGIS((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glPixelTexGenParameterfSGIS(int pname, Single param)
        {
            Delegates.glPixelTexGenParameterfSGIS((int)pname, (Single)param);
        }

        public static 
        void glPixelTexGenParameterfvSGIS(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPixelTexGenParameterfvSGIS((int)pname, (Single*)@params);
            }
        }

        public static 
        void glPixelTexGenParameterfvSGIS(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glPixelTexGenParameterfvSGIS((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glPixelTexGenParameterfvSGIS(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glPixelTexGenParameterfvSGIS((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetPixelTexGenParameterivSGIS(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetPixelTexGenParameterivSGIS((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetPixelTexGenParameterivSGIS(int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetPixelTexGenParameterivSGIS((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetPixelTexGenParameterivSGIS(int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetPixelTexGenParameterivSGIS((int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetPixelTexGenParameterfvSGIS(int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetPixelTexGenParameterfvSGIS((int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetPixelTexGenParameterfvSGIS(int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetPixelTexGenParameterfvSGIS((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetPixelTexGenParameterfvSGIS(int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetPixelTexGenParameterfvSGIS((int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glTexImage4DSGIS(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 size4d, Int32 border, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexImage4DSGIS((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (Int32)border, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexImage4DSGIS(int target, Int32 level, int internalformat, Int32 width, Int32 height, Int32 depth, Int32 size4d, Int32 border, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexImage4DSGIS((int)target, (Int32)level, (int)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (Int32)border, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glTexSubImage4DSGIS(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 woffset, Int32 width, Int32 height, Int32 depth, Int32 size4d, int format, int type, IntPtr pixels)
        {
            unsafe
            {
                Delegates.glTexSubImage4DSGIS((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)woffset, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (int)format, (int)type, (IntPtr)pixels);
            }
        }

        public static 
        void glTexSubImage4DSGIS(int target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 woffset, Int32 width, Int32 height, Int32 depth, Int32 size4d, int format, int type, [In, Out] object pixels)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage4DSGIS((int)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)woffset, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (int)format, (int)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }
        }

        public static 
        void glDetailTexFuncSGIS(int target, Int32 n, IntPtr points)
        {
            unsafe
            {
                Delegates.glDetailTexFuncSGIS((int)target, (Int32)n, (Single*)points);
            }
        }

        public static 
        void glDetailTexFuncSGIS(int target, Int32 n, Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glDetailTexFuncSGIS((int)target, (Int32)n, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glDetailTexFuncSGIS(int target, Int32 n, ref Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glDetailTexFuncSGIS((int)target, (Int32)n, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glGetDetailTexFuncSGIS(int target, [Out] IntPtr points)
        {
            unsafe
            {
                Delegates.glGetDetailTexFuncSGIS((int)target, (Single*)points);
            }
        }

        public static 
        void glGetDetailTexFuncSGIS(int target, [Out] Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glGetDetailTexFuncSGIS((int)target, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glGetDetailTexFuncSGIS(int target, [Out] out Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glGetDetailTexFuncSGIS((int)target, (Single*)points_ptr);
                    points = *points_ptr;
                }
            }
        }

        public static 
        void glSharpenTexFuncSGIS(int target, Int32 n, IntPtr points)
        {
            unsafe
            {
                Delegates.glSharpenTexFuncSGIS((int)target, (Int32)n, (Single*)points);
            }
        }

        public static 
        void glSharpenTexFuncSGIS(int target, Int32 n, Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glSharpenTexFuncSGIS((int)target, (Int32)n, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glSharpenTexFuncSGIS(int target, Int32 n, ref Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glSharpenTexFuncSGIS((int)target, (Int32)n, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glGetSharpenTexFuncSGIS(int target, [Out] IntPtr points)
        {
            unsafe
            {
                Delegates.glGetSharpenTexFuncSGIS((int)target, (Single*)points);
            }
        }

        public static 
        void glGetSharpenTexFuncSGIS(int target, [Out] Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glGetSharpenTexFuncSGIS((int)target, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glGetSharpenTexFuncSGIS(int target, [Out] out Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glGetSharpenTexFuncSGIS((int)target, (Single*)points_ptr);
                    points = *points_ptr;
                }
            }
        }

        public static 
        void glSampleMaskSGIS(Single value, Int32 invert)
        {
            Delegates.glSampleMaskSGIS((Single)value, (Int32)invert);
        }

        public static 
        void glSamplePatternSGIS(int pattern)
        {
            Delegates.glSamplePatternSGIS((int)pattern);
        }

        public static 
        void glPointParameterfSGIS(int pname, Single param)
        {
            Delegates.glPointParameterfSGIS((int)pname, (Single)param);
        }

        public static 
        void glPointParameterfvSGIS(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPointParameterfvSGIS((int)pname, (Single*)@params);
            }
        }

        public static 
        void glPointParameterfvSGIS(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glPointParameterfvSGIS((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glPointParameterfvSGIS(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glPointParameterfvSGIS((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFogFuncSGIS(Int32 n, IntPtr points)
        {
            unsafe
            {
                Delegates.glFogFuncSGIS((Int32)n, (Single*)points);
            }
        }

        public static 
        void glFogFuncSGIS(Int32 n, Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glFogFuncSGIS((Int32)n, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glFogFuncSGIS(Int32 n, ref Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glFogFuncSGIS((Int32)n, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glGetFogFuncSGIS([Out] IntPtr points)
        {
            unsafe
            {
                Delegates.glGetFogFuncSGIS((Single*)points);
            }
        }

        public static 
        void glGetFogFuncSGIS([Out] Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glGetFogFuncSGIS((Single*)points_ptr);
                }
            }
        }

        public static 
        void glGetFogFuncSGIS([Out] out Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glGetFogFuncSGIS((Single*)points_ptr);
                    points = *points_ptr;
                }
            }
        }

        public static 
        void glTextureColorMaskSGIS(Int32 red, Int32 green, Int32 blue, Int32 alpha)
        {
            Delegates.glTextureColorMaskSGIS((Int32)red, (Int32)green, (Int32)blue, (Int32)alpha);
        }

        public static 
        void glColorTableSGI(int target, int internalformat, Int32 width, int format, int type, IntPtr table)
        {
            unsafe
            {
                Delegates.glColorTableSGI((int)target, (int)internalformat, (Int32)width, (int)format, (int)type, (IntPtr)table);
            }
        }

        public static 
        void glColorTableSGI(int target, int internalformat, Int32 width, int format, int type, [In, Out] object table)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorTableSGI((int)target, (int)internalformat, (Int32)width, (int)format, (int)type, (IntPtr)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }
        }

        public static 
        void glColorTableParameterfvSGI(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glColorTableParameterfvSGI((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glColorTableParameterfvSGI(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glColorTableParameterfvSGI((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glColorTableParameterfvSGI(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glColorTableParameterfvSGI((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glColorTableParameterivSGI(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glColorTableParameterivSGI((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glColorTableParameterivSGI(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glColorTableParameterivSGI((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glColorTableParameterivSGI(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glColorTableParameterivSGI((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glCopyColorTableSGI(int target, int internalformat, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyColorTableSGI((int)target, (int)internalformat, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void glGetColorTableSGI(int target, int format, int type, [Out] IntPtr table)
        {
            unsafe
            {
                Delegates.glGetColorTableSGI((int)target, (int)format, (int)type, (IntPtr)table);
            }
        }

        public static 
        void glGetColorTableSGI(int target, int format, int type, [In, Out] object table)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetColorTableSGI((int)target, (int)format, (int)type, (IntPtr)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }
        }

        public static 
        void glGetColorTableParameterfvSGI(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetColorTableParameterfvSGI((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetColorTableParameterfvSGI(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameterfvSGI((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetColorTableParameterfvSGI(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameterfvSGI((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetColorTableParameterivSGI(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetColorTableParameterivSGI((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetColorTableParameterivSGI(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameterivSGI((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetColorTableParameterivSGI(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameterivSGI((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glPixelTexGenSGIX(int mode)
        {
            Delegates.glPixelTexGenSGIX((int)mode);
        }

        public static 
        void glSpriteParameterfSGIX(int pname, Single param)
        {
            Delegates.glSpriteParameterfSGIX((int)pname, (Single)param);
        }

        public static 
        void glSpriteParameterfvSGIX(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glSpriteParameterfvSGIX((int)pname, (Single*)@params);
            }
        }

        public static 
        void glSpriteParameterfvSGIX(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glSpriteParameterfvSGIX((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glSpriteParameterfvSGIX(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glSpriteParameterfvSGIX((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glSpriteParameteriSGIX(int pname, Int32 param)
        {
            Delegates.glSpriteParameteriSGIX((int)pname, (Int32)param);
        }

        public static 
        void glSpriteParameterivSGIX(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glSpriteParameterivSGIX((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glSpriteParameterivSGIX(int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glSpriteParameterivSGIX((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glSpriteParameterivSGIX(int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glSpriteParameterivSGIX((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        Int32 glGetInstrumentsSGIX()
        {
            return Delegates.glGetInstrumentsSGIX();
        }

        public static 
        void glInstrumentsBufferSGIX(Int32 size, [Out] IntPtr buffer)
        {
            unsafe
            {
                Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer);
            }
        }

        public static 
        void glInstrumentsBufferSGIX(Int32 size, [Out] Int32[] buffer)
        {
            unsafe
            {
                fixed (Int32* buffer_ptr = buffer)
                {
                    Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer_ptr);
                }
            }
        }

        public static 
        void glInstrumentsBufferSGIX(Int32 size, [Out] out Int32 buffer)
        {
            unsafe
            {
                fixed (Int32* buffer_ptr = &buffer)
                {
                    Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }

        public static 
        Int32 glPollInstrumentsSGIX([Out] IntPtr marker_p)
        {
            unsafe
            {
                return Delegates.glPollInstrumentsSGIX((Int32*)marker_p);
            }
        }

        public static 
        Int32 glPollInstrumentsSGIX([Out] Int32[] marker_p)
        {
            unsafe
            {
                fixed (Int32* marker_p_ptr = marker_p)
                {
                    return Delegates.glPollInstrumentsSGIX((Int32*)marker_p_ptr);
                }
            }
        }

        public static 
        Int32 glPollInstrumentsSGIX([Out] out Int32 marker_p)
        {
            unsafe
            {
                fixed (Int32* marker_p_ptr = &marker_p)
                {
                    Int32 retval = Delegates.glPollInstrumentsSGIX((Int32*)marker_p_ptr);
                    marker_p = *marker_p_ptr;
                    return retval;
                }
            }
        }

        public static 
        void glReadInstrumentsSGIX(Int32 marker)
        {
            Delegates.glReadInstrumentsSGIX((Int32)marker);
        }

        public static 
        void glStartInstrumentsSGIX()
        {
            Delegates.glStartInstrumentsSGIX();
        }

        public static 
        void glStopInstrumentsSGIX(Int32 marker)
        {
            Delegates.glStopInstrumentsSGIX((Int32)marker);
        }

        public static 
        void glFrameZoomSGIX(Int32 factor)
        {
            Delegates.glFrameZoomSGIX((Int32)factor);
        }

        public static 
        void glTagSampleBufferSGIX()
        {
            Delegates.glTagSampleBufferSGIX();
        }

        public static 
        void glDeformationMap3dSGIX(int target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, IntPtr points)
        {
            unsafe
            {
                Delegates.glDeformationMap3dSGIX((int)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points);
            }
        }

        public static 
        void glDeformationMap3dSGIX(int target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, Double[] points)
        {
            unsafe
            {
                fixed (Double* points_ptr = points)
                {
                    Delegates.glDeformationMap3dSGIX((int)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points_ptr);
                }
            }
        }

        public static 
        void glDeformationMap3dSGIX(int target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, ref Double points)
        {
            unsafe
            {
                fixed (Double* points_ptr = &points)
                {
                    Delegates.glDeformationMap3dSGIX((int)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points_ptr);
                }
            }
        }

        public static 
        void glDeformationMap3fSGIX(int target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, IntPtr points)
        {
            unsafe
            {
                Delegates.glDeformationMap3fSGIX((int)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points);
            }
        }

        public static 
        void glDeformationMap3fSGIX(int target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glDeformationMap3fSGIX((int)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glDeformationMap3fSGIX(int target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, ref Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glDeformationMap3fSGIX((int)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points_ptr);
                }
            }
        }

        public static 
        void glDeformSGIX(int mask)
        {
            Delegates.glDeformSGIX((int)mask);
        }

        public static 
        void glLoadIdentityDeformationMapSGIX(int mask)
        {
            Delegates.glLoadIdentityDeformationMapSGIX((int)mask);
        }

        public static 
        void glReferencePlaneSGIX(IntPtr equation)
        {
            unsafe
            {
                Delegates.glReferencePlaneSGIX((Double*)equation);
            }
        }

        public static 
        void glReferencePlaneSGIX(Double[] equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = equation)
                {
                    Delegates.glReferencePlaneSGIX((Double*)equation_ptr);
                }
            }
        }

        public static 
        void glReferencePlaneSGIX(ref Double equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = &equation)
                {
                    Delegates.glReferencePlaneSGIX((Double*)equation_ptr);
                }
            }
        }

        public static 
        void glFlushRasterSGIX()
        {
            Delegates.glFlushRasterSGIX();
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetListParameterfvSGIX(UInt32 list, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetListParameterfvSGIX(Int32 list, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetListParameterfvSGIX(UInt32 list, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetListParameterfvSGIX(Int32 list, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetListParameterfvSGIX(UInt32 list, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetListParameterfvSGIX(Int32 list, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetListParameterivSGIX(UInt32 list, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetListParameterivSGIX(Int32 list, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetListParameterivSGIX(UInt32 list, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetListParameterivSGIX(Int32 list, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetListParameterivSGIX(UInt32 list, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetListParameterivSGIX(Int32 list, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glListParameterfSGIX(UInt32 list, int pname, Single param)
        {
            Delegates.glListParameterfSGIX((UInt32)list, (int)pname, (Single)param);
        }

        public static 
        void glListParameterfSGIX(Int32 list, int pname, Single param)
        {
            Delegates.glListParameterfSGIX((UInt32)list, (int)pname, (Single)param);
        }

        [System.CLSCompliant(false)]
        public static 
        void glListParameterfvSGIX(UInt32 list, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glListParameterfvSGIX(Int32 list, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glListParameterfvSGIX(UInt32 list, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glListParameterfvSGIX(Int32 list, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glListParameterfvSGIX(UInt32 list, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glListParameterfvSGIX(Int32 list, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glListParameterfvSGIX((UInt32)list, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glListParameteriSGIX(UInt32 list, int pname, Int32 param)
        {
            Delegates.glListParameteriSGIX((UInt32)list, (int)pname, (Int32)param);
        }

        public static 
        void glListParameteriSGIX(Int32 list, int pname, Int32 param)
        {
            Delegates.glListParameteriSGIX((UInt32)list, (int)pname, (Int32)param);
        }

        [System.CLSCompliant(false)]
        public static 
        void glListParameterivSGIX(UInt32 list, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glListParameterivSGIX(Int32 list, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glListParameterivSGIX(UInt32 list, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glListParameterivSGIX(Int32 list, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glListParameterivSGIX(UInt32 list, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glListParameterivSGIX(Int32 list, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glListParameterivSGIX((UInt32)list, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentColorMaterialSGIX(int face, int mode)
        {
            Delegates.glFragmentColorMaterialSGIX((int)face, (int)mode);
        }

        public static 
        void glFragmentLightfSGIX(int light, int pname, Single param)
        {
            Delegates.glFragmentLightfSGIX((int)light, (int)pname, (Single)param);
        }

        public static 
        void glFragmentLightfvSGIX(int light, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glFragmentLightfvSGIX((int)light, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glFragmentLightfvSGIX(int light, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glFragmentLightfvSGIX((int)light, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentLightfvSGIX(int light, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glFragmentLightfvSGIX((int)light, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentLightiSGIX(int light, int pname, Int32 param)
        {
            Delegates.glFragmentLightiSGIX((int)light, (int)pname, (Int32)param);
        }

        public static 
        void glFragmentLightivSGIX(int light, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glFragmentLightivSGIX((int)light, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glFragmentLightivSGIX(int light, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glFragmentLightivSGIX((int)light, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentLightivSGIX(int light, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glFragmentLightivSGIX((int)light, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentLightModelfSGIX(int pname, Single param)
        {
            Delegates.glFragmentLightModelfSGIX((int)pname, (Single)param);
        }

        public static 
        void glFragmentLightModelfvSGIX(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glFragmentLightModelfvSGIX((int)pname, (Single*)@params);
            }
        }

        public static 
        void glFragmentLightModelfvSGIX(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glFragmentLightModelfvSGIX((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentLightModelfvSGIX(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glFragmentLightModelfvSGIX((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentLightModeliSGIX(int pname, Int32 param)
        {
            Delegates.glFragmentLightModeliSGIX((int)pname, (Int32)param);
        }

        public static 
        void glFragmentLightModelivSGIX(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glFragmentLightModelivSGIX((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glFragmentLightModelivSGIX(int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glFragmentLightModelivSGIX((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentLightModelivSGIX(int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glFragmentLightModelivSGIX((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentMaterialfSGIX(int face, int pname, Single param)
        {
            Delegates.glFragmentMaterialfSGIX((int)face, (int)pname, (Single)param);
        }

        public static 
        void glFragmentMaterialfvSGIX(int face, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glFragmentMaterialfvSGIX((int)face, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glFragmentMaterialfvSGIX(int face, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glFragmentMaterialfvSGIX((int)face, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentMaterialfvSGIX(int face, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glFragmentMaterialfvSGIX((int)face, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentMaterialiSGIX(int face, int pname, Int32 param)
        {
            Delegates.glFragmentMaterialiSGIX((int)face, (int)pname, (Int32)param);
        }

        public static 
        void glFragmentMaterialivSGIX(int face, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glFragmentMaterialivSGIX((int)face, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glFragmentMaterialivSGIX(int face, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glFragmentMaterialivSGIX((int)face, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glFragmentMaterialivSGIX(int face, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glFragmentMaterialivSGIX((int)face, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFragmentLightfvSGIX(int light, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFragmentLightfvSGIX((int)light, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetFragmentLightfvSGIX(int light, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetFragmentLightfvSGIX((int)light, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFragmentLightfvSGIX(int light, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetFragmentLightfvSGIX((int)light, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetFragmentLightivSGIX(int light, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFragmentLightivSGIX((int)light, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetFragmentLightivSGIX(int light, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetFragmentLightivSGIX((int)light, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFragmentLightivSGIX(int light, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetFragmentLightivSGIX((int)light, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetFragmentMaterialfvSGIX(int face, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFragmentMaterialfvSGIX((int)face, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetFragmentMaterialfvSGIX(int face, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetFragmentMaterialfvSGIX((int)face, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFragmentMaterialfvSGIX(int face, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetFragmentMaterialfvSGIX((int)face, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetFragmentMaterialivSGIX(int face, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFragmentMaterialivSGIX((int)face, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetFragmentMaterialivSGIX(int face, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetFragmentMaterialivSGIX((int)face, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFragmentMaterialivSGIX(int face, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetFragmentMaterialivSGIX((int)face, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glLightEnviSGIX(int pname, Int32 param)
        {
            Delegates.glLightEnviSGIX((int)pname, (Int32)param);
        }

        [System.CLSCompliant(false)]
        public static 
        void glAsyncMarkerSGIX(UInt32 marker)
        {
            Delegates.glAsyncMarkerSGIX((UInt32)marker);
        }

        public static 
        void glAsyncMarkerSGIX(Int32 marker)
        {
            Delegates.glAsyncMarkerSGIX((UInt32)marker);
        }

        public static 
        Int32 glFinishAsyncSGIX([Out] IntPtr markerp)
        {
            unsafe
            {
                return Delegates.glFinishAsyncSGIX((UInt32*)markerp);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glFinishAsyncSGIX([Out] UInt32[] markerp)
        {
            unsafe
            {
                fixed (UInt32* markerp_ptr = markerp)
                {
                    return Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
                }
            }
        }

        public static 
        Int32 glFinishAsyncSGIX([Out] Int32[] markerp)
        {
            unsafe
            {
                fixed (Int32* markerp_ptr = markerp)
                {
                    return Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glFinishAsyncSGIX([Out] out UInt32 markerp)
        {
            unsafe
            {
                fixed (UInt32* markerp_ptr = &markerp)
                {
                    Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
                    markerp = *markerp_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glFinishAsyncSGIX([Out] out Int32 markerp)
        {
            unsafe
            {
                fixed (Int32* markerp_ptr = &markerp)
                {
                    Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
                    markerp = *markerp_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glPollAsyncSGIX([Out] IntPtr markerp)
        {
            unsafe
            {
                return Delegates.glPollAsyncSGIX((UInt32*)markerp);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glPollAsyncSGIX([Out] UInt32[] markerp)
        {
            unsafe
            {
                fixed (UInt32* markerp_ptr = markerp)
                {
                    return Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
                }
            }
        }

        public static 
        Int32 glPollAsyncSGIX([Out] Int32[] markerp)
        {
            unsafe
            {
                fixed (Int32* markerp_ptr = markerp)
                {
                    return Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glPollAsyncSGIX([Out] out UInt32 markerp)
        {
            unsafe
            {
                fixed (UInt32* markerp_ptr = &markerp)
                {
                    Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
                    markerp = *markerp_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glPollAsyncSGIX([Out] out Int32 markerp)
        {
            unsafe
            {
                fixed (Int32* markerp_ptr = &markerp)
                {
                    Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
                    markerp = *markerp_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glGenAsyncMarkersSGIX(Int32 range)
        {
            return Delegates.glGenAsyncMarkersSGIX((Int32)range);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteAsyncMarkersSGIX(UInt32 marker, Int32 range)
        {
            Delegates.glDeleteAsyncMarkersSGIX((UInt32)marker, (Int32)range);
        }

        public static 
        void glDeleteAsyncMarkersSGIX(Int32 marker, Int32 range)
        {
            Delegates.glDeleteAsyncMarkersSGIX((UInt32)marker, (Int32)range);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsAsyncMarkerSGIX(UInt32 marker)
        {
            return Delegates.glIsAsyncMarkerSGIX((UInt32)marker);
        }

        public static 
        Int32 glIsAsyncMarkerSGIX(Int32 marker)
        {
            return Delegates.glIsAsyncMarkerSGIX((UInt32)marker);
        }

        public static 
        void glIglooInterfaceSGIX(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glIglooInterfaceSGIX((int)pname, (IntPtr)@params);
            }
        }

        public static 
        void glIglooInterfaceSGIX(int pname, [In, Out] object @params)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glIglooInterfaceSGIX((int)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }
        }

        public static 
        void glImageTransformParameteriHP(int target, int pname, Int32 param)
        {
            Delegates.glImageTransformParameteriHP((int)target, (int)pname, (Int32)param);
        }

        public static 
        void glImageTransformParameterfHP(int target, int pname, Single param)
        {
            Delegates.glImageTransformParameterfHP((int)target, (int)pname, (Single)param);
        }

        public static 
        void glImageTransformParameterivHP(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glImageTransformParameterivHP((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glImageTransformParameterivHP(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glImageTransformParameterivHP((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glImageTransformParameterivHP(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glImageTransformParameterivHP((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glImageTransformParameterfvHP(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glImageTransformParameterfvHP((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glImageTransformParameterfvHP(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glImageTransformParameterfvHP((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glImageTransformParameterfvHP(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glImageTransformParameterfvHP((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetImageTransformParameterivHP(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetImageTransformParameterivHP((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetImageTransformParameterivHP(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetImageTransformParameterivHP((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetImageTransformParameterivHP(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetImageTransformParameterivHP((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetImageTransformParameterfvHP(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetImageTransformParameterfvHP((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetImageTransformParameterfvHP(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetImageTransformParameterfvHP((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetImageTransformParameterfvHP(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetImageTransformParameterfvHP((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glHintPGI(int target, Int32 mode)
        {
            Delegates.glHintPGI((int)target, (Int32)mode);
        }

        public static 
        void glVertexPointervINTEL(Int32 size, int type, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexPointervINTEL((Int32)size, (int)type, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexPointervINTEL(Int32 size, int type, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexPointervINTEL((Int32)size, (int)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glNormalPointervINTEL(int type, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glNormalPointervINTEL((int)type, (IntPtr)pointer);
            }
        }

        public static 
        void glNormalPointervINTEL(int type, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glNormalPointervINTEL((int)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glColorPointervINTEL(Int32 size, int type, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glColorPointervINTEL((Int32)size, (int)type, (IntPtr)pointer);
            }
        }

        public static 
        void glColorPointervINTEL(Int32 size, int type, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorPointervINTEL((Int32)size, (int)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glTexCoordPointervINTEL(Int32 size, int type, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glTexCoordPointervINTEL((Int32)size, (int)type, (IntPtr)pointer);
            }
        }

        public static 
        void glTexCoordPointervINTEL(Int32 size, int type, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexCoordPointervINTEL((Int32)size, (int)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glFinishTextureSUNX()
        {
            Delegates.glFinishTextureSUNX();
        }

        [System.CLSCompliant(false)]
        public static 
        void glGlobalAlphaFactorbSUN(SByte factor)
        {
            Delegates.glGlobalAlphaFactorbSUN((SByte)factor);
        }

        public static 
        void glGlobalAlphaFactorbSUN(Byte factor)
        {
            Delegates.glGlobalAlphaFactorbSUN((SByte)factor);
        }

        public static 
        void glGlobalAlphaFactorsSUN(Int16 factor)
        {
            Delegates.glGlobalAlphaFactorsSUN((Int16)factor);
        }

        public static 
        void glGlobalAlphaFactoriSUN(Int32 factor)
        {
            Delegates.glGlobalAlphaFactoriSUN((Int32)factor);
        }

        public static 
        void glGlobalAlphaFactorfSUN(Single factor)
        {
            Delegates.glGlobalAlphaFactorfSUN((Single)factor);
        }

        public static 
        void glGlobalAlphaFactordSUN(Double factor)
        {
            Delegates.glGlobalAlphaFactordSUN((Double)factor);
        }

        public static 
        void glGlobalAlphaFactorubSUN(Byte factor)
        {
            Delegates.glGlobalAlphaFactorubSUN((Byte)factor);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGlobalAlphaFactorusSUN(UInt16 factor)
        {
            Delegates.glGlobalAlphaFactorusSUN((UInt16)factor);
        }

        public static 
        void glGlobalAlphaFactorusSUN(Int16 factor)
        {
            Delegates.glGlobalAlphaFactorusSUN((UInt16)factor);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGlobalAlphaFactoruiSUN(UInt32 factor)
        {
            Delegates.glGlobalAlphaFactoruiSUN((UInt32)factor);
        }

        public static 
        void glGlobalAlphaFactoruiSUN(Int32 factor)
        {
            Delegates.glGlobalAlphaFactoruiSUN((UInt32)factor);
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiSUN(UInt32 code)
        {
            Delegates.glReplacementCodeuiSUN((UInt32)code);
        }

        public static 
        void glReplacementCodeuiSUN(Int32 code)
        {
            Delegates.glReplacementCodeuiSUN((UInt32)code);
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeusSUN(UInt16 code)
        {
            Delegates.glReplacementCodeusSUN((UInt16)code);
        }

        public static 
        void glReplacementCodeusSUN(Int16 code)
        {
            Delegates.glReplacementCodeusSUN((UInt16)code);
        }

        public static 
        void glReplacementCodeubSUN(Byte code)
        {
            Delegates.glReplacementCodeubSUN((Byte)code);
        }

        public static 
        void glReplacementCodeuivSUN(IntPtr code)
        {
            unsafe
            {
                Delegates.glReplacementCodeuivSUN((UInt32*)code);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuivSUN(UInt32[] code)
        {
            unsafe
            {
                fixed (UInt32* code_ptr = code)
                {
                    Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuivSUN(Int32[] code)
        {
            unsafe
            {
                fixed (Int32* code_ptr = code)
                {
                    Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuivSUN(ref UInt32 code)
        {
            unsafe
            {
                fixed (UInt32* code_ptr = &code)
                {
                    Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuivSUN(ref Int32 code)
        {
            unsafe
            {
                fixed (Int32* code_ptr = &code)
                {
                    Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeusvSUN(IntPtr code)
        {
            unsafe
            {
                Delegates.glReplacementCodeusvSUN((UInt16*)code);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeusvSUN(UInt16[] code)
        {
            unsafe
            {
                fixed (UInt16* code_ptr = code)
                {
                    Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeusvSUN(Int16[] code)
        {
            unsafe
            {
                fixed (Int16* code_ptr = code)
                {
                    Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeusvSUN(ref UInt16 code)
        {
            unsafe
            {
                fixed (UInt16* code_ptr = &code)
                {
                    Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeusvSUN(ref Int16 code)
        {
            unsafe
            {
                fixed (Int16* code_ptr = &code)
                {
                    Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeubvSUN(IntPtr code)
        {
            unsafe
            {
                Delegates.glReplacementCodeubvSUN((Byte*)code);
            }
        }

        public static 
        void glReplacementCodeubvSUN(Byte[] code)
        {
            unsafe
            {
                fixed (Byte* code_ptr = code)
                {
                    Delegates.glReplacementCodeubvSUN((Byte*)code_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeubvSUN(ref Byte code)
        {
            unsafe
            {
                fixed (Byte* code_ptr = &code)
                {
                    Delegates.glReplacementCodeubvSUN((Byte*)code_ptr);
                }
            }
        }

        public static 
        void glReplacementCodePointerSUN(int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glReplacementCodePointerSUN((int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glReplacementCodePointerSUN(int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glReplacementCodePointerSUN((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glColor4ubVertex2fSUN(Byte r, Byte g, Byte b, Byte a, Single x, Single y)
        {
            Delegates.glColor4ubVertex2fSUN((Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y);
        }

        public static 
        void glColor4ubVertex2fvSUN(IntPtr c, IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4ubVertex2fvSUN((Byte*)c, (Single*)v);
            }
        }

        public static 
        void glColor4ubVertex2fvSUN(IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4ubVertex2fvSUN((Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex2fvSUN(IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4ubVertex2fvSUN((Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex2fvSUN(Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4ubVertex2fvSUN(Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex2fvSUN(Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex2fvSUN(ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4ubVertex2fvSUN(ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex2fvSUN(ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex3fSUN(Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
        {
            Delegates.glColor4ubVertex3fSUN((Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glColor4ubVertex3fvSUN(IntPtr c, IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4ubVertex3fvSUN((Byte*)c, (Single*)v);
            }
        }

        public static 
        void glColor4ubVertex3fvSUN(IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4ubVertex3fvSUN((Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex3fvSUN(IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4ubVertex3fvSUN((Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex3fvSUN(Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4ubVertex3fvSUN(Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex3fvSUN(Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex3fvSUN(ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4ubVertex3fvSUN(ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4ubVertex3fvSUN(ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor3fVertex3fSUN(Single r, Single g, Single b, Single x, Single y, Single z)
        {
            Delegates.glColor3fVertex3fSUN((Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glColor3fVertex3fvSUN(IntPtr c, IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3fVertex3fvSUN((Single*)c, (Single*)v);
            }
        }

        public static 
        void glColor3fVertex3fvSUN(IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor3fVertex3fvSUN((Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor3fVertex3fvSUN(IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor3fVertex3fvSUN((Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor3fVertex3fvSUN(Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor3fVertex3fvSUN(Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor3fVertex3fvSUN(Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor3fVertex3fvSUN(ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor3fVertex3fvSUN(ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor3fVertex3fvSUN(ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3fVertex3fSUN(Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glNormal3fVertex3fSUN((Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glNormal3fVertex3fvSUN(IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glNormal3fVertex3fvSUN((Single*)n, (Single*)v);
            }
        }

        public static 
        void glNormal3fVertex3fvSUN(IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glNormal3fVertex3fvSUN((Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3fVertex3fvSUN(IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glNormal3fVertex3fvSUN((Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3fVertex3fvSUN(Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glNormal3fVertex3fvSUN(Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3fVertex3fvSUN(Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3fVertex3fvSUN(ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glNormal3fVertex3fvSUN(ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3fVertex3fvSUN(ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fSUN(Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glColor4fNormal3fVertex3fSUN((Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n, (Single*)v);
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glColor4fNormal3fVertex3fvSUN(ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fVertex3fSUN(Single s, Single t, Single x, Single y, Single z)
        {
            Delegates.glTexCoord2fVertex3fSUN((Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glTexCoord2fVertex3fvSUN(IntPtr tc, IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2fVertex3fvSUN((Single*)tc, (Single*)v);
            }
        }

        public static 
        void glTexCoord2fVertex3fvSUN(IntPtr tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fVertex3fvSUN((Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fVertex3fvSUN(IntPtr tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fVertex3fvSUN((Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fVertex3fvSUN(Single[] tc, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fVertex3fvSUN(Single[] tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fVertex3fvSUN(Single[] tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fVertex3fvSUN(ref Single tc, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fVertex3fvSUN(ref Single tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fVertex3fvSUN(ref Single tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fVertex4fSUN(Single s, Single t, Single p, Single q, Single x, Single y, Single z, Single w)
        {
            Delegates.glTexCoord4fVertex4fSUN((Single)s, (Single)t, (Single)p, (Single)q, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glTexCoord4fVertex4fvSUN(IntPtr tc, IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord4fVertex4fvSUN((Single*)tc, (Single*)v);
            }
        }

        public static 
        void glTexCoord4fVertex4fvSUN(IntPtr tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fVertex4fvSUN((Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fVertex4fvSUN(IntPtr tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fVertex4fvSUN((Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fVertex4fvSUN(Single[] tc, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fVertex4fvSUN(Single[] tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fVertex4fvSUN(Single[] tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fVertex4fvSUN(ref Single tc, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fVertex4fvSUN(ref Single tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fVertex4fvSUN(ref Single tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fSUN(Single s, Single t, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
        {
            Delegates.glTexCoord2fColor4ubVertex3fSUN((Single)s, (Single)t, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c, (Single*)v);
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(IntPtr tc, ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(Single[] tc, ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4ubVertex3fvSUN(ref Single tc, ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fSUN(Single s, Single t, Single r, Single g, Single b, Single x, Single y, Single z)
        {
            Delegates.glTexCoord2fColor3fVertex3fSUN((Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)v);
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(IntPtr tc, ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(Single[] tc, ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor3fVertex3fvSUN(ref Single tc, ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fSUN(Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glTexCoord2fNormal3fVertex3fSUN((Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n, (Single*)v);
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(IntPtr tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(Single[] tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fNormal3fVertex3fvSUN(ref Single tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fSUN(Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glTexCoord2fColor4fNormal3fVertex3fSUN((Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v);
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(Single[] tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2fColor4fNormal3fVertex3fvSUN(ref Single tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fSUN(Single s, Single t, Single p, Single q, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z, Single w)
        {
            Delegates.glTexCoord4fColor4fNormal3fVertex4fSUN((Single)s, (Single)t, (Single)p, (Single)q, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v);
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(IntPtr tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(Single[] tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4fColor4fNormal3fVertex4fvSUN(ref Single tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiVertex3fSUN(UInt32 rc, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiVertex3fSUN((UInt32)rc, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiVertex3fSUN(Int32 rc, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiVertex3fSUN((UInt32)rc, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(IntPtr rc, IntPtr v)
        {
            unsafe
            {
                Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v);
            }
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(IntPtr rc, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(IntPtr rc, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiVertex3fvSUN(UInt32[] rc, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(Int32[] rc, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiVertex3fvSUN(UInt32[] rc, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(Int32[] rc, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiVertex3fvSUN(UInt32[] rc, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(Int32[] rc, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiVertex3fvSUN(ref UInt32 rc, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(ref Int32 rc, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiVertex3fvSUN(ref UInt32 rc, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(ref Int32 rc, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiVertex3fvSUN(ref UInt32 rc, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiVertex3fvSUN(ref Int32 rc, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fSUN(UInt32 rc, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiColor4ubVertex3fSUN((UInt32)rc, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fSUN(Int32 rc, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiColor4ubVertex3fSUN((UInt32)rc, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v);
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(IntPtr rc, ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(UInt32[] rc, ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(Int32[] rc, ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, Byte[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, Byte[] c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, Byte[] c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Byte* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, ref Byte c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, ref Byte c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref UInt32 rc, ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4ubVertex3fvSUN(ref Int32 rc, ref Byte c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Byte* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fSUN(UInt32 rc, Single r, Single g, Single b, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiColor3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fSUN(Int32 rc, Single r, Single g, Single b, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiColor3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v);
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(IntPtr rc, ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(UInt32[] rc, ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(Int32[] rc, ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, IntPtr c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, IntPtr c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, IntPtr c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, Single[] c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, Single[] c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, Single[] c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, ref Single c, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, ref Single c, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref UInt32 rc, ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor3fVertex3fvSUN(ref Int32 rc, ref Single c, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fSUN(UInt32 rc, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiNormal3fVertex3fSUN((UInt32)rc, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fSUN(Int32 rc, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiNormal3fVertex3fSUN((UInt32)rc, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v);
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(IntPtr rc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(UInt32[] rc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(Int32[] rc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref UInt32 rc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiNormal3fVertex3fvSUN(ref Int32 rc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fSUN(UInt32 rc, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fSUN(Int32 rc, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v);
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fSUN(UInt32 rc, Single s, Single t, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fSUN(Int32 rc, Single s, Single t, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr v)
        {
            unsafe
            {
                Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v);
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(UInt32 rc, Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(Int32 rc, Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v);
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(UInt32 rc, Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(Int32 rc, Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
        {
            Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, IntPtr tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, Single[] tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(IntPtr rc, ref Single tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, IntPtr tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, IntPtr tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, Single[] tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, Single[] tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(UInt32[] rc, ref Single tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(Int32[] rc, ref Single tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, IntPtr tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, IntPtr tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, Single[] tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, Single[] tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, IntPtr c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, Single[] c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, IntPtr n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, IntPtr n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, IntPtr n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, Single[] n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, Single[] n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, Single[] n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, ref Single n, IntPtr v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, ref Single n, Single[] v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref UInt32 rc, ref Single tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (UInt32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref Int32 rc, ref Single tc, ref Single c, ref Single n, ref Single v)
        {
            unsafe
            {
                fixed (Int32* rc_ptr = &rc)
                fixed (Single* tc_ptr = &tc)
                fixed (Single* c_ptr = &c)
                fixed (Single* n_ptr = &n)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glDrawMeshArraysSUN(int mode, Int32 first, Int32 count, Int32 width)
        {
            Delegates.glDrawMeshArraysSUN((int)mode, (Int32)first, (Int32)count, (Int32)width);
        }

        public static 
        void glBlendFuncSeparateINGR(int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dfactorAlpha)
        {
            Delegates.glBlendFuncSeparateINGR((int)sfactorRGB, (int)dfactorRGB, (int)sfactorAlpha, (int)dfactorAlpha);
        }

        public static 
        void glFlushVertexArrayRangeNV()
        {
            Delegates.glFlushVertexArrayRangeNV();
        }

        public static 
        void glVertexArrayRangeNV(Int32 length, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexArrayRangeNV((Int32)length, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexArrayRangeNV(Int32 length, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexArrayRangeNV((Int32)length, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glCombinerParameterfvNV(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glCombinerParameterfvNV((int)pname, (Single*)@params);
            }
        }

        public static 
        void glCombinerParameterfvNV(int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glCombinerParameterfvNV((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glCombinerParameterfvNV(int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glCombinerParameterfvNV((int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glCombinerParameterfNV(int pname, Single param)
        {
            Delegates.glCombinerParameterfNV((int)pname, (Single)param);
        }

        public static 
        void glCombinerParameterivNV(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glCombinerParameterivNV((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glCombinerParameterivNV(int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glCombinerParameterivNV((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glCombinerParameterivNV(int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glCombinerParameterivNV((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glCombinerParameteriNV(int pname, Int32 param)
        {
            Delegates.glCombinerParameteriNV((int)pname, (Int32)param);
        }

        public static 
        void glCombinerInputNV(int stage, int portion, int variable, int input, int mapping, int componentUsage)
        {
            Delegates.glCombinerInputNV((int)stage, (int)portion, (int)variable, (int)input, (int)mapping, (int)componentUsage);
        }

        public static 
        void glCombinerOutputNV(int stage, int portion, int abOutput, int cdOutput, int sumOutput, int scale, int bias, Int32 abDotProduct, Int32 cdDotProduct, Int32 muxSum)
        {
            Delegates.glCombinerOutputNV((int)stage, (int)portion, (int)abOutput, (int)cdOutput, (int)sumOutput, (int)scale, (int)bias, (Int32)abDotProduct, (Int32)cdDotProduct, (Int32)muxSum);
        }

        public static 
        void glFinalCombinerInputNV(int variable, int input, int mapping, int componentUsage)
        {
            Delegates.glFinalCombinerInputNV((int)variable, (int)input, (int)mapping, (int)componentUsage);
        }

        public static 
        void glGetCombinerInputParameterfvNV(int stage, int portion, int variable, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetCombinerInputParameterfvNV((int)stage, (int)portion, (int)variable, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetCombinerInputParameterfvNV(int stage, int portion, int variable, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetCombinerInputParameterfvNV((int)stage, (int)portion, (int)variable, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetCombinerInputParameterfvNV(int stage, int portion, int variable, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetCombinerInputParameterfvNV((int)stage, (int)portion, (int)variable, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetCombinerInputParameterivNV(int stage, int portion, int variable, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetCombinerInputParameterivNV((int)stage, (int)portion, (int)variable, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetCombinerInputParameterivNV(int stage, int portion, int variable, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetCombinerInputParameterivNV((int)stage, (int)portion, (int)variable, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetCombinerInputParameterivNV(int stage, int portion, int variable, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetCombinerInputParameterivNV((int)stage, (int)portion, (int)variable, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetCombinerOutputParameterfvNV(int stage, int portion, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetCombinerOutputParameterfvNV((int)stage, (int)portion, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetCombinerOutputParameterfvNV(int stage, int portion, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetCombinerOutputParameterfvNV((int)stage, (int)portion, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetCombinerOutputParameterfvNV(int stage, int portion, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetCombinerOutputParameterfvNV((int)stage, (int)portion, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetCombinerOutputParameterivNV(int stage, int portion, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetCombinerOutputParameterivNV((int)stage, (int)portion, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetCombinerOutputParameterivNV(int stage, int portion, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetCombinerOutputParameterivNV((int)stage, (int)portion, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetCombinerOutputParameterivNV(int stage, int portion, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetCombinerOutputParameterivNV((int)stage, (int)portion, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetFinalCombinerInputParameterfvNV(int variable, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFinalCombinerInputParameterfvNV((int)variable, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetFinalCombinerInputParameterfvNV(int variable, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetFinalCombinerInputParameterfvNV((int)variable, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFinalCombinerInputParameterfvNV(int variable, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetFinalCombinerInputParameterfvNV((int)variable, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetFinalCombinerInputParameterivNV(int variable, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFinalCombinerInputParameterivNV((int)variable, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetFinalCombinerInputParameterivNV(int variable, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetFinalCombinerInputParameterivNV((int)variable, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFinalCombinerInputParameterivNV(int variable, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetFinalCombinerInputParameterivNV((int)variable, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glDeleteFencesNV(Int32 n, IntPtr fences)
        {
            unsafe
            {
                Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteFencesNV(Int32 n, UInt32[] fences)
        {
            unsafe
            {
                fixed (UInt32* fences_ptr = fences)
                {
                    Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        public static 
        void glDeleteFencesNV(Int32 n, Int32[] fences)
        {
            unsafe
            {
                fixed (Int32* fences_ptr = fences)
                {
                    Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteFencesNV(Int32 n, ref UInt32 fences)
        {
            unsafe
            {
                fixed (UInt32* fences_ptr = &fences)
                {
                    Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        public static 
        void glDeleteFencesNV(Int32 n, ref Int32 fences)
        {
            unsafe
            {
                fixed (Int32* fences_ptr = &fences)
                {
                    Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        public static 
        void glGenFencesNV(Int32 n, [Out] IntPtr fences)
        {
            unsafe
            {
                Delegates.glGenFencesNV((Int32)n, (UInt32*)fences);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenFencesNV(Int32 n, [Out] UInt32[] fences)
        {
            unsafe
            {
                fixed (UInt32* fences_ptr = fences)
                {
                    Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        public static 
        void glGenFencesNV(Int32 n, [Out] Int32[] fences)
        {
            unsafe
            {
                fixed (Int32* fences_ptr = fences)
                {
                    Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenFencesNV(Int32 n, [Out] out UInt32 fences)
        {
            unsafe
            {
                fixed (UInt32* fences_ptr = &fences)
                {
                    Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
                    fences = *fences_ptr;
                }
            }
        }

        public static 
        void glGenFencesNV(Int32 n, [Out] out Int32 fences)
        {
            unsafe
            {
                fixed (Int32* fences_ptr = &fences)
                {
                    Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
                    fences = *fences_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsFenceNV(UInt32 fence)
        {
            return Delegates.glIsFenceNV((UInt32)fence);
        }

        public static 
        Int32 glIsFenceNV(Int32 fence)
        {
            return Delegates.glIsFenceNV((UInt32)fence);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glTestFenceNV(UInt32 fence)
        {
            return Delegates.glTestFenceNV((UInt32)fence);
        }

        public static 
        Int32 glTestFenceNV(Int32 fence)
        {
            return Delegates.glTestFenceNV((UInt32)fence);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetFenceivNV(UInt32 fence, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFenceivNV((UInt32)fence, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetFenceivNV(Int32 fence, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetFenceivNV((UInt32)fence, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetFenceivNV(UInt32 fence, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetFenceivNV((UInt32)fence, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetFenceivNV(Int32 fence, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetFenceivNV((UInt32)fence, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetFenceivNV(UInt32 fence, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetFenceivNV((UInt32)fence, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetFenceivNV(Int32 fence, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetFenceivNV((UInt32)fence, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glFinishFenceNV(UInt32 fence)
        {
            Delegates.glFinishFenceNV((UInt32)fence);
        }

        public static 
        void glFinishFenceNV(Int32 fence)
        {
            Delegates.glFinishFenceNV((UInt32)fence);
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetFenceNV(UInt32 fence, int condition)
        {
            Delegates.glSetFenceNV((UInt32)fence, (int)condition);
        }

        public static 
        void glSetFenceNV(Int32 fence, int condition)
        {
            Delegates.glSetFenceNV((UInt32)fence, (int)condition);
        }

        [System.CLSCompliant(false)]
        public static 
        void glMapControlPointsNV(int target, UInt32 index, int type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, Int32 packed, IntPtr points)
        {
            unsafe
            {
                Delegates.glMapControlPointsNV((int)target, (UInt32)index, (int)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (Int32)packed, (IntPtr)points);
            }
        }

        public static 
        void glMapControlPointsNV(int target, Int32 index, int type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, Int32 packed, IntPtr points)
        {
            unsafe
            {
                Delegates.glMapControlPointsNV((int)target, (UInt32)index, (int)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (Int32)packed, (IntPtr)points);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMapControlPointsNV(int target, UInt32 index, int type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, Int32 packed, [In, Out] object points)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle points_ptr = System.Runtime.InteropServices.GCHandle.Alloc(points, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMapControlPointsNV((int)target, (UInt32)index, (int)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (Int32)packed, (IntPtr)points_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    points_ptr.Free();
                }
            }
        }

        public static 
        void glMapControlPointsNV(int target, Int32 index, int type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, Int32 packed, [In, Out] object points)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle points_ptr = System.Runtime.InteropServices.GCHandle.Alloc(points, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMapControlPointsNV((int)target, (UInt32)index, (int)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (Int32)packed, (IntPtr)points_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    points_ptr.Free();
                }
            }
        }

        public static 
        void glMapParameterivNV(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glMapParameterivNV((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glMapParameterivNV(int target, int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glMapParameterivNV((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glMapParameterivNV(int target, int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glMapParameterivNV((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glMapParameterfvNV(int target, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glMapParameterfvNV((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glMapParameterfvNV(int target, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glMapParameterfvNV((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glMapParameterfvNV(int target, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glMapParameterfvNV((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetMapControlPointsNV(int target, UInt32 index, int type, Int32 ustride, Int32 vstride, Int32 packed, [Out] IntPtr points)
        {
            unsafe
            {
                Delegates.glGetMapControlPointsNV((int)target, (UInt32)index, (int)type, (Int32)ustride, (Int32)vstride, (Int32)packed, (IntPtr)points);
            }
        }

        public static 
        void glGetMapControlPointsNV(int target, Int32 index, int type, Int32 ustride, Int32 vstride, Int32 packed, [Out] IntPtr points)
        {
            unsafe
            {
                Delegates.glGetMapControlPointsNV((int)target, (UInt32)index, (int)type, (Int32)ustride, (Int32)vstride, (Int32)packed, (IntPtr)points);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetMapControlPointsNV(int target, UInt32 index, int type, Int32 ustride, Int32 vstride, Int32 packed, [In, Out] object points)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle points_ptr = System.Runtime.InteropServices.GCHandle.Alloc(points, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetMapControlPointsNV((int)target, (UInt32)index, (int)type, (Int32)ustride, (Int32)vstride, (Int32)packed, (IntPtr)points_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    points_ptr.Free();
                }
            }
        }

        public static 
        void glGetMapControlPointsNV(int target, Int32 index, int type, Int32 ustride, Int32 vstride, Int32 packed, [In, Out] object points)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle points_ptr = System.Runtime.InteropServices.GCHandle.Alloc(points, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetMapControlPointsNV((int)target, (UInt32)index, (int)type, (Int32)ustride, (Int32)vstride, (Int32)packed, (IntPtr)points_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    points_ptr.Free();
                }
            }
        }

        public static 
        void glGetMapParameterivNV(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMapParameterivNV((int)target, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetMapParameterivNV(int target, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetMapParameterivNV((int)target, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMapParameterivNV(int target, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetMapParameterivNV((int)target, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMapParameterfvNV(int target, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMapParameterfvNV((int)target, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetMapParameterfvNV(int target, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetMapParameterfvNV((int)target, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMapParameterfvNV(int target, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetMapParameterfvNV((int)target, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetMapAttribParameterivNV(int target, UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMapAttribParameterivNV((int)target, (UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetMapAttribParameterivNV(int target, Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMapAttribParameterivNV((int)target, (UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetMapAttribParameterivNV(int target, UInt32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetMapAttribParameterivNV((int)target, (UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMapAttribParameterivNV(int target, Int32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetMapAttribParameterivNV((int)target, (UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetMapAttribParameterivNV(int target, UInt32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetMapAttribParameterivNV((int)target, (UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMapAttribParameterivNV(int target, Int32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetMapAttribParameterivNV((int)target, (UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetMapAttribParameterfvNV(int target, UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMapAttribParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetMapAttribParameterfvNV(int target, Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetMapAttribParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetMapAttribParameterfvNV(int target, UInt32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetMapAttribParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetMapAttribParameterfvNV(int target, Int32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetMapAttribParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetMapAttribParameterfvNV(int target, UInt32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetMapAttribParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetMapAttribParameterfvNV(int target, Int32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetMapAttribParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glEvalMapsNV(int target, int mode)
        {
            Delegates.glEvalMapsNV((int)target, (int)mode);
        }

        public static 
        void glCombinerStageParameterfvNV(int stage, int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glCombinerStageParameterfvNV((int)stage, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glCombinerStageParameterfvNV(int stage, int pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glCombinerStageParameterfvNV((int)stage, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glCombinerStageParameterfvNV(int stage, int pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glCombinerStageParameterfvNV((int)stage, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetCombinerStageParameterfvNV(int stage, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetCombinerStageParameterfvNV((int)stage, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetCombinerStageParameterfvNV(int stage, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetCombinerStageParameterfvNV((int)stage, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetCombinerStageParameterfvNV(int stage, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetCombinerStageParameterfvNV((int)stage, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, IntPtr programs, [Out] IntPtr residences)
        {
            unsafe
            {
                return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs, (Int32*)residences);
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, IntPtr programs, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, IntPtr programs, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreProgramsResidentNV(Int32 n, UInt32[] programs, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = programs)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences);
                }
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, Int32[] programs, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = programs)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreProgramsResidentNV(Int32 n, UInt32[] programs, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = programs)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, Int32[] programs, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = programs)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreProgramsResidentNV(Int32 n, UInt32[] programs, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = programs)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, Int32[] programs, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = programs)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreProgramsResidentNV(Int32 n, ref UInt32 programs, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = &programs)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences);
                }
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, ref Int32 programs, [Out] IntPtr residences)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = &programs)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreProgramsResidentNV(Int32 n, ref UInt32 programs, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = &programs)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences_ptr);
                }
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, ref Int32 programs, [Out] Int32[] residences)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = &programs)
                fixed (Int32* residences_ptr = residences)
                {
                    return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glAreProgramsResidentNV(Int32 n, ref UInt32 programs, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = &programs)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        public static 
        Int32 glAreProgramsResidentNV(Int32 n, ref Int32 programs, [Out] out Int32 residences)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = &programs)
                fixed (Int32* residences_ptr = &residences)
                {
                    Int32 retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (Int32*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindProgramNV(int target, UInt32 id)
        {
            Delegates.glBindProgramNV((int)target, (UInt32)id);
        }

        public static 
        void glBindProgramNV(int target, Int32 id)
        {
            Delegates.glBindProgramNV((int)target, (UInt32)id);
        }

        public static 
        void glDeleteProgramsNV(Int32 n, IntPtr programs)
        {
            unsafe
            {
                Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteProgramsNV(Int32 n, UInt32[] programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = programs)
                {
                    Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glDeleteProgramsNV(Int32 n, Int32[] programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = programs)
                {
                    Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteProgramsNV(Int32 n, ref UInt32 programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = &programs)
                {
                    Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glDeleteProgramsNV(Int32 n, ref Int32 programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = &programs)
                {
                    Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glExecuteProgramNV(int target, UInt32 id, IntPtr @params)
        {
            unsafe
            {
                Delegates.glExecuteProgramNV((int)target, (UInt32)id, (Single*)@params);
            }
        }

        public static 
        void glExecuteProgramNV(int target, Int32 id, IntPtr @params)
        {
            unsafe
            {
                Delegates.glExecuteProgramNV((int)target, (UInt32)id, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glExecuteProgramNV(int target, UInt32 id, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glExecuteProgramNV((int)target, (UInt32)id, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glExecuteProgramNV(int target, Int32 id, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glExecuteProgramNV((int)target, (UInt32)id, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glExecuteProgramNV(int target, UInt32 id, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glExecuteProgramNV((int)target, (UInt32)id, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glExecuteProgramNV(int target, Int32 id, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glExecuteProgramNV((int)target, (UInt32)id, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGenProgramsNV(Int32 n, [Out] IntPtr programs)
        {
            unsafe
            {
                Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenProgramsNV(Int32 n, [Out] UInt32[] programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = programs)
                {
                    Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glGenProgramsNV(Int32 n, [Out] Int32[] programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = programs)
                {
                    Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenProgramsNV(Int32 n, [Out] out UInt32 programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = &programs)
                {
                    Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    programs = *programs_ptr;
                }
            }
        }

        public static 
        void glGenProgramsNV(Int32 n, [Out] out Int32 programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = &programs)
                {
                    Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    programs = *programs_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramParameterdvNV(int target, UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramParameterdvNV((int)target, (UInt32)index, (int)pname, (Double*)@params);
            }
        }

        public static 
        void glGetProgramParameterdvNV(int target, Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramParameterdvNV((int)target, (UInt32)index, (int)pname, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramParameterdvNV(int target, UInt32 index, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramParameterdvNV((int)target, (UInt32)index, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramParameterdvNV(int target, Int32 index, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramParameterdvNV((int)target, (UInt32)index, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramParameterdvNV(int target, UInt32 index, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramParameterdvNV((int)target, (UInt32)index, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramParameterdvNV(int target, Int32 index, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramParameterdvNV((int)target, (UInt32)index, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramParameterfvNV(int target, UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetProgramParameterfvNV(int target, Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramParameterfvNV(int target, UInt32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramParameterfvNV(int target, Int32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramParameterfvNV(int target, UInt32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramParameterfvNV(int target, Int32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramParameterfvNV((int)target, (UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramivNV(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramivNV((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetProgramivNV(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramivNV((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramivNV(UInt32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramivNV((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramivNV(Int32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramivNV((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramivNV(UInt32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramivNV((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramivNV(Int32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramivNV((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramStringNV(UInt32 id, int pname, [Out] IntPtr program)
        {
            unsafe
            {
                Delegates.glGetProgramStringNV((UInt32)id, (int)pname, (Byte*)program);
            }
        }

        public static 
        void glGetProgramStringNV(Int32 id, int pname, [Out] IntPtr program)
        {
            unsafe
            {
                Delegates.glGetProgramStringNV((UInt32)id, (int)pname, (Byte*)program);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramStringNV(UInt32 id, int pname, [Out] Byte[] program)
        {
            unsafe
            {
                fixed (Byte* program_ptr = program)
                {
                    Delegates.glGetProgramStringNV((UInt32)id, (int)pname, (Byte*)program_ptr);
                }
            }
        }

        public static 
        void glGetProgramStringNV(Int32 id, int pname, [Out] Byte[] program)
        {
            unsafe
            {
                fixed (Byte* program_ptr = program)
                {
                    Delegates.glGetProgramStringNV((UInt32)id, (int)pname, (Byte*)program_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramStringNV(UInt32 id, int pname, [Out] out Byte program)
        {
            unsafe
            {
                fixed (Byte* program_ptr = &program)
                {
                    Delegates.glGetProgramStringNV((UInt32)id, (int)pname, (Byte*)program_ptr);
                    program = *program_ptr;
                }
            }
        }

        public static 
        void glGetProgramStringNV(Int32 id, int pname, [Out] out Byte program)
        {
            unsafe
            {
                fixed (Byte* program_ptr = &program)
                {
                    Delegates.glGetProgramStringNV((UInt32)id, (int)pname, (Byte*)program_ptr);
                    program = *program_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetTrackMatrixivNV(int target, UInt32 address, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTrackMatrixivNV((int)target, (UInt32)address, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetTrackMatrixivNV(int target, Int32 address, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetTrackMatrixivNV((int)target, (UInt32)address, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetTrackMatrixivNV(int target, UInt32 address, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTrackMatrixivNV((int)target, (UInt32)address, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetTrackMatrixivNV(int target, Int32 address, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTrackMatrixivNV((int)target, (UInt32)address, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetTrackMatrixivNV(int target, UInt32 address, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTrackMatrixivNV((int)target, (UInt32)address, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetTrackMatrixivNV(int target, Int32 address, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTrackMatrixivNV((int)target, (UInt32)address, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdvNV(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribdvNV((UInt32)index, (int)pname, (Double*)@params);
            }
        }

        public static 
        void glGetVertexAttribdvNV(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribdvNV((UInt32)index, (int)pname, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdvNV(UInt32 index, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdvNV((UInt32)index, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribdvNV(Int32 index, int pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdvNV((UInt32)index, (int)pname, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribdvNV(UInt32 index, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdvNV((UInt32)index, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribdvNV(Int32 index, int pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdvNV((UInt32)index, (int)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfvNV(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribfvNV((UInt32)index, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetVertexAttribfvNV(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribfvNV((UInt32)index, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfvNV(UInt32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfvNV((UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribfvNV(Int32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfvNV((UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribfvNV(UInt32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfvNV((UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribfvNV(Int32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfvNV((UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribivNV(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribivNV((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetVertexAttribivNV(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribivNV((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribivNV(UInt32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribivNV((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribivNV(Int32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribivNV((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribivNV(UInt32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribivNV((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribivNV(Int32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribivNV((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribPointervNV(UInt32 index, int pname, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glGetVertexAttribPointervNV((UInt32)index, (int)pname, (IntPtr)pointer);
            }
        }

        public static 
        void glGetVertexAttribPointervNV(Int32 index, int pname, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glGetVertexAttribPointervNV((UInt32)index, (int)pname, (IntPtr)pointer);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribPointervNV(UInt32 index, int pname, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointervNV((UInt32)index, (int)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glGetVertexAttribPointervNV(Int32 index, int pname, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointervNV((UInt32)index, (int)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsProgramNV(UInt32 id)
        {
            return Delegates.glIsProgramNV((UInt32)id);
        }

        public static 
        Int32 glIsProgramNV(Int32 id)
        {
            return Delegates.glIsProgramNV((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        void glLoadProgramNV(int target, UInt32 id, Int32 len, IntPtr program)
        {
            unsafe
            {
                Delegates.glLoadProgramNV((int)target, (UInt32)id, (Int32)len, (Byte*)program);
            }
        }

        public static 
        void glLoadProgramNV(int target, Int32 id, Int32 len, IntPtr program)
        {
            unsafe
            {
                Delegates.glLoadProgramNV((int)target, (UInt32)id, (Int32)len, (Byte*)program);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glLoadProgramNV(int target, UInt32 id, Int32 len, Byte[] program)
        {
            unsafe
            {
                fixed (Byte* program_ptr = program)
                {
                    Delegates.glLoadProgramNV((int)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
                }
            }
        }

        public static 
        void glLoadProgramNV(int target, Int32 id, Int32 len, Byte[] program)
        {
            unsafe
            {
                fixed (Byte* program_ptr = program)
                {
                    Delegates.glLoadProgramNV((int)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glLoadProgramNV(int target, UInt32 id, Int32 len, ref Byte program)
        {
            unsafe
            {
                fixed (Byte* program_ptr = &program)
                {
                    Delegates.glLoadProgramNV((int)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
                }
            }
        }

        public static 
        void glLoadProgramNV(int target, Int32 id, Int32 len, ref Byte program)
        {
            unsafe
            {
                fixed (Byte* program_ptr = &program)
                {
                    Delegates.glLoadProgramNV((int)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameter4dNV(int target, UInt32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glProgramParameter4dNV((int)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glProgramParameter4dNV(int target, Int32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glProgramParameter4dNV((int)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameter4dvNV(int target, UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramParameter4dvNV((int)target, (UInt32)index, (Double*)v);
            }
        }

        public static 
        void glProgramParameter4dvNV(int target, Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramParameter4dvNV((int)target, (UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameter4dvNV(int target, UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramParameter4dvNV((int)target, (UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramParameter4dvNV(int target, Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramParameter4dvNV((int)target, (UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameter4dvNV(int target, UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramParameter4dvNV((int)target, (UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramParameter4dvNV(int target, Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramParameter4dvNV((int)target, (UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameter4fNV(int target, UInt32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glProgramParameter4fNV((int)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glProgramParameter4fNV(int target, Int32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glProgramParameter4fNV((int)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameter4fvNV(int target, UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramParameter4fvNV((int)target, (UInt32)index, (Single*)v);
            }
        }

        public static 
        void glProgramParameter4fvNV(int target, Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramParameter4fvNV((int)target, (UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameter4fvNV(int target, UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramParameter4fvNV((int)target, (UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramParameter4fvNV(int target, Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramParameter4fvNV((int)target, (UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameter4fvNV(int target, UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramParameter4fvNV((int)target, (UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramParameter4fvNV(int target, Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramParameter4fvNV((int)target, (UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameters4dvNV(int target, UInt32 index, UInt32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramParameters4dvNV((int)target, (UInt32)index, (UInt32)count, (Double*)v);
            }
        }

        public static 
        void glProgramParameters4dvNV(int target, Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramParameters4dvNV((int)target, (UInt32)index, (UInt32)count, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameters4dvNV(int target, UInt32 index, UInt32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramParameters4dvNV((int)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramParameters4dvNV(int target, Int32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramParameters4dvNV((int)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameters4dvNV(int target, UInt32 index, UInt32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramParameters4dvNV((int)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramParameters4dvNV(int target, Int32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramParameters4dvNV((int)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameters4fvNV(int target, UInt32 index, UInt32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramParameters4fvNV((int)target, (UInt32)index, (UInt32)count, (Single*)v);
            }
        }

        public static 
        void glProgramParameters4fvNV(int target, Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramParameters4fvNV((int)target, (UInt32)index, (UInt32)count, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameters4fvNV(int target, UInt32 index, UInt32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramParameters4fvNV((int)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramParameters4fvNV(int target, Int32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramParameters4fvNV((int)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramParameters4fvNV(int target, UInt32 index, UInt32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramParameters4fvNV((int)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramParameters4fvNV(int target, Int32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramParameters4fvNV((int)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glRequestResidentProgramsNV(Int32 n, IntPtr programs)
        {
            unsafe
            {
                Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glRequestResidentProgramsNV(Int32 n, UInt32[] programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = programs)
                {
                    Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glRequestResidentProgramsNV(Int32 n, Int32[] programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = programs)
                {
                    Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glRequestResidentProgramsNV(Int32 n, ref UInt32 programs)
        {
            unsafe
            {
                fixed (UInt32* programs_ptr = &programs)
                {
                    Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        public static 
        void glRequestResidentProgramsNV(Int32 n, ref Int32 programs)
        {
            unsafe
            {
                fixed (Int32* programs_ptr = &programs)
                {
                    Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTrackMatrixNV(int target, UInt32 address, int matrix, int transform)
        {
            Delegates.glTrackMatrixNV((int)target, (UInt32)address, (int)matrix, (int)transform);
        }

        public static 
        void glTrackMatrixNV(int target, Int32 address, int matrix, int transform)
        {
            Delegates.glTrackMatrixNV((int)target, (UInt32)address, (int)matrix, (int)transform);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribPointerNV(UInt32 index, Int32 fsize, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexAttribPointerNV(Int32 index, Int32 fsize, int type, Int32 stride, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (int)type, (Int32)stride, (IntPtr)pointer);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribPointerNV(UInt32 index, Int32 fsize, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexAttribPointerNV(Int32 index, Int32 fsize, int type, Int32 stride, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dNV(UInt32 index, Double x)
        {
            Delegates.glVertexAttrib1dNV((UInt32)index, (Double)x);
        }

        public static 
        void glVertexAttrib1dNV(Int32 index, Double x)
        {
            Delegates.glVertexAttrib1dNV((UInt32)index, (Double)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib1dvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dvNV(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1dvNV(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1dvNV(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1dvNV(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fNV(UInt32 index, Single x)
        {
            Delegates.glVertexAttrib1fNV((UInt32)index, (Single)x);
        }

        public static 
        void glVertexAttrib1fNV(Int32 index, Single x)
        {
            Delegates.glVertexAttrib1fNV((UInt32)index, (Single)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib1fvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fvNV(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1fvNV(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1fvNV(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1fvNV(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1sNV(UInt32 index, Int16 x)
        {
            Delegates.glVertexAttrib1sNV((UInt32)index, (Int16)x);
        }

        public static 
        void glVertexAttrib1sNV(Int32 index, Int16 x)
        {
            Delegates.glVertexAttrib1sNV((UInt32)index, (Int16)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1svNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib1svNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1svNV(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1svNV(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1svNV(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1svNV(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dNV(UInt32 index, Double x, Double y)
        {
            Delegates.glVertexAttrib2dNV((UInt32)index, (Double)x, (Double)y);
        }

        public static 
        void glVertexAttrib2dNV(Int32 index, Double x, Double y)
        {
            Delegates.glVertexAttrib2dNV((UInt32)index, (Double)x, (Double)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib2dvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dvNV(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2dvNV(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2dvNV(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2dvNV(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fNV(UInt32 index, Single x, Single y)
        {
            Delegates.glVertexAttrib2fNV((UInt32)index, (Single)x, (Single)y);
        }

        public static 
        void glVertexAttrib2fNV(Int32 index, Single x, Single y)
        {
            Delegates.glVertexAttrib2fNV((UInt32)index, (Single)x, (Single)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib2fvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fvNV(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2fvNV(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2fvNV(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2fvNV(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2sNV(UInt32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2sNV((UInt32)index, (Int16)x, (Int16)y);
        }

        public static 
        void glVertexAttrib2sNV(Int32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2sNV((UInt32)index, (Int16)x, (Int16)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2svNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib2svNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2svNV(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2svNV(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2svNV(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2svNV(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dNV(UInt32 index, Double x, Double y, Double z)
        {
            Delegates.glVertexAttrib3dNV((UInt32)index, (Double)x, (Double)y, (Double)z);
        }

        public static 
        void glVertexAttrib3dNV(Int32 index, Double x, Double y, Double z)
        {
            Delegates.glVertexAttrib3dNV((UInt32)index, (Double)x, (Double)y, (Double)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib3dvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dvNV(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3dvNV(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3dvNV(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3dvNV(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fNV(UInt32 index, Single x, Single y, Single z)
        {
            Delegates.glVertexAttrib3fNV((UInt32)index, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glVertexAttrib3fNV(Int32 index, Single x, Single y, Single z)
        {
            Delegates.glVertexAttrib3fNV((UInt32)index, (Single)x, (Single)y, (Single)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib3fvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fvNV(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3fvNV(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3fvNV(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3fvNV(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3sNV(UInt32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glVertexAttrib3sNV(Int32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3svNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib3svNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3svNV(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3svNV(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3svNV(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3svNV(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dNV(UInt32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexAttrib4dNV((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glVertexAttrib4dNV(Int32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexAttrib4dNV((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v);
            }
        }

        public static 
        void glVertexAttrib4dvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dvNV(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4dvNV(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4dvNV(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4dvNV(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fNV(UInt32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexAttrib4fNV((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glVertexAttrib4fNV(Int32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexAttrib4fNV((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v);
            }
        }

        public static 
        void glVertexAttrib4fvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fvNV(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4fvNV(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4fvNV(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4fvNV(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4sNV(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void glVertexAttrib4sNV(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4svNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v);
            }
        }

        public static 
        void glVertexAttrib4svNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4svNV(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4svNV(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4svNV(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4svNV(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubNV(UInt32 index, Byte x, Byte y, Byte z, Byte w)
        {
            Delegates.glVertexAttrib4ubNV((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
        }

        public static 
        void glVertexAttrib4ubNV(Int32 index, Byte x, Byte y, Byte z, Byte w)
        {
            Delegates.glVertexAttrib4ubNV((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v);
            }
        }

        public static 
        void glVertexAttrib4ubvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubvNV(UInt32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4ubvNV(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4ubvNV(UInt32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4ubvNV(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1dvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v);
            }
        }

        public static 
        void glVertexAttribs1dvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1dvNV(UInt32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs1dvNV(Int32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1dvNV(UInt32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs1dvNV(Int32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1fvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v);
            }
        }

        public static 
        void glVertexAttribs1fvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1fvNV(UInt32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs1fvNV(Int32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1fvNV(UInt32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs1fvNV(Int32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1svNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v);
            }
        }

        public static 
        void glVertexAttribs1svNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1svNV(UInt32 index, Int32 count, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs1svNV(Int32 index, Int32 count, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1svNV(UInt32 index, Int32 count, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs1svNV(Int32 index, Int32 count, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2dvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v);
            }
        }

        public static 
        void glVertexAttribs2dvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2dvNV(UInt32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs2dvNV(Int32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2dvNV(UInt32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs2dvNV(Int32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2fvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v);
            }
        }

        public static 
        void glVertexAttribs2fvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2fvNV(UInt32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs2fvNV(Int32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2fvNV(UInt32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs2fvNV(Int32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2svNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v);
            }
        }

        public static 
        void glVertexAttribs2svNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2svNV(UInt32 index, Int32 count, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs2svNV(Int32 index, Int32 count, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2svNV(UInt32 index, Int32 count, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs2svNV(Int32 index, Int32 count, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3dvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v);
            }
        }

        public static 
        void glVertexAttribs3dvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3dvNV(UInt32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs3dvNV(Int32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3dvNV(UInt32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs3dvNV(Int32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3fvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v);
            }
        }

        public static 
        void glVertexAttribs3fvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3fvNV(UInt32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs3fvNV(Int32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3fvNV(UInt32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs3fvNV(Int32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3svNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v);
            }
        }

        public static 
        void glVertexAttribs3svNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3svNV(UInt32 index, Int32 count, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs3svNV(Int32 index, Int32 count, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3svNV(UInt32 index, Int32 count, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs3svNV(Int32 index, Int32 count, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4dvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v);
            }
        }

        public static 
        void glVertexAttribs4dvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4dvNV(UInt32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4dvNV(Int32 index, Int32 count, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4dvNV(UInt32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4dvNV(Int32 index, Int32 count, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4fvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v);
            }
        }

        public static 
        void glVertexAttribs4fvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4fvNV(UInt32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4fvNV(Int32 index, Int32 count, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4fvNV(UInt32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4fvNV(Int32 index, Int32 count, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4svNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v);
            }
        }

        public static 
        void glVertexAttribs4svNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4svNV(UInt32 index, Int32 count, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4svNV(Int32 index, Int32 count, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4svNV(UInt32 index, Int32 count, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4svNV(Int32 index, Int32 count, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4ubvNV(UInt32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v);
            }
        }

        public static 
        void glVertexAttribs4ubvNV(Int32 index, Int32 count, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4ubvNV(UInt32 index, Int32 count, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4ubvNV(Int32 index, Int32 count, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4ubvNV(UInt32 index, Int32 count, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4ubvNV(Int32 index, Int32 count, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void glGenOcclusionQueriesNV(Int32 n, [Out] IntPtr ids)
        {
            unsafe
            {
                Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenOcclusionQueriesNV(Int32 n, [Out] UInt32[] ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = ids)
                {
                    Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glGenOcclusionQueriesNV(Int32 n, [Out] Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenOcclusionQueriesNV(Int32 n, [Out] out UInt32 ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = &ids)
                {
                    Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }

        public static 
        void glGenOcclusionQueriesNV(Int32 n, [Out] out Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }

        public static 
        void glDeleteOcclusionQueriesNV(Int32 n, IntPtr ids)
        {
            unsafe
            {
                Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteOcclusionQueriesNV(Int32 n, UInt32[] ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = ids)
                {
                    Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glDeleteOcclusionQueriesNV(Int32 n, Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteOcclusionQueriesNV(Int32 n, ref UInt32 ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = &ids)
                {
                    Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void glDeleteOcclusionQueriesNV(Int32 n, ref Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsOcclusionQueryNV(UInt32 id)
        {
            return Delegates.glIsOcclusionQueryNV((UInt32)id);
        }

        public static 
        Int32 glIsOcclusionQueryNV(Int32 id)
        {
            return Delegates.glIsOcclusionQueryNV((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBeginOcclusionQueryNV(UInt32 id)
        {
            Delegates.glBeginOcclusionQueryNV((UInt32)id);
        }

        public static 
        void glBeginOcclusionQueryNV(Int32 id)
        {
            Delegates.glBeginOcclusionQueryNV((UInt32)id);
        }

        public static 
        void glEndOcclusionQueryNV()
        {
            Delegates.glEndOcclusionQueryNV();
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetOcclusionQueryivNV(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetOcclusionQueryivNV((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetOcclusionQueryivNV(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetOcclusionQueryivNV((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetOcclusionQueryivNV(UInt32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetOcclusionQueryivNV((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetOcclusionQueryivNV(Int32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetOcclusionQueryivNV((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetOcclusionQueryivNV(UInt32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetOcclusionQueryivNV((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetOcclusionQueryivNV(Int32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetOcclusionQueryivNV((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetOcclusionQueryuivNV(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetOcclusionQueryuivNV((UInt32)id, (int)pname, (UInt32*)@params);
            }
        }

        public static 
        void glGetOcclusionQueryuivNV(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetOcclusionQueryuivNV((UInt32)id, (int)pname, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetOcclusionQueryuivNV(UInt32 id, int pname, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetOcclusionQueryuivNV((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetOcclusionQueryuivNV(Int32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetOcclusionQueryuivNV((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetOcclusionQueryuivNV(UInt32 id, int pname, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetOcclusionQueryuivNV((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetOcclusionQueryuivNV(Int32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetOcclusionQueryuivNV((UInt32)id, (int)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glPointParameteriNV(int pname, Int32 param)
        {
            Delegates.glPointParameteriNV((int)pname, (Int32)param);
        }

        public static 
        void glPointParameterivNV(int pname, IntPtr @params)
        {
            unsafe
            {
                Delegates.glPointParameterivNV((int)pname, (Int32*)@params);
            }
        }

        public static 
        void glPointParameterivNV(int pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glPointParameterivNV((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glPointParameterivNV(int pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glPointParameterivNV((int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fNV(UInt32 id, Int32 len, IntPtr name, Single x, Single y, Single z, Single w)
        {
            unsafe
            {
                Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name, (Single)x, (Single)y, (Single)z, (Single)w);
            }
        }

        public static 
        void glProgramNamedParameter4fNV(Int32 id, Int32 len, IntPtr name, Single x, Single y, Single z, Single w)
        {
            unsafe
            {
                Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name, (Single)x, (Single)y, (Single)z, (Single)w);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fNV(UInt32 id, Int32 len, Byte[] name, Single x, Single y, Single z, Single w)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fNV(Int32 id, Int32 len, Byte[] name, Single x, Single y, Single z, Single w)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fNV(UInt32 id, Int32 len, ref Byte name, Single x, Single y, Single z, Single w)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fNV(Int32 id, Int32 len, ref Byte name, Single x, Single y, Single z, Single w)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dNV(UInt32 id, Int32 len, IntPtr name, Double x, Double y, Double z, Double w)
        {
            unsafe
            {
                Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name, (Double)x, (Double)y, (Double)z, (Double)w);
            }
        }

        public static 
        void glProgramNamedParameter4dNV(Int32 id, Int32 len, IntPtr name, Double x, Double y, Double z, Double w)
        {
            unsafe
            {
                Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name, (Double)x, (Double)y, (Double)z, (Double)w);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dNV(UInt32 id, Int32 len, Byte[] name, Double x, Double y, Double z, Double w)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dNV(Int32 id, Int32 len, Byte[] name, Double x, Double y, Double z, Double w)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dNV(UInt32 id, Int32 len, ref Byte name, Double x, Double y, Double z, Double w)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dNV(Int32 id, Int32 len, ref Byte name, Double x, Double y, Double z, Double w)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, IntPtr name, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v);
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, IntPtr name, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, IntPtr name, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, IntPtr name, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, IntPtr name, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, IntPtr name, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, Byte[] name, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, Byte[] name, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, Byte[] name, Single[] v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, Byte[] name, Single[] v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, Byte[] name, ref Single v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, Byte[] name, ref Single v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, ref Byte name, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, ref Byte name, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, ref Byte name, Single[] v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, ref Byte name, Single[] v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Single* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4fvNV(UInt32 id, Int32 len, ref Byte name, ref Single v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4fvNV(Int32 id, Int32 len, ref Byte name, ref Single v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, IntPtr name, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v);
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, IntPtr name, IntPtr v)
        {
            unsafe
            {
                Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, IntPtr name, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, IntPtr name, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, IntPtr name, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, IntPtr name, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, Byte[] name, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, Byte[] name, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, Byte[] name, Double[] v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, Byte[] name, Double[] v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, Byte[] name, ref Double v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, Byte[] name, ref Double v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, ref Byte name, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, ref Byte name, IntPtr v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, ref Byte name, Double[] v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, ref Byte name, Double[] v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Double* v_ptr = v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramNamedParameter4dvNV(UInt32 id, Int32 len, ref Byte name, ref Double v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                }
            }
        }

        public static 
        void glProgramNamedParameter4dvNV(Int32 id, Int32 len, ref Byte name, ref Double v)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, IntPtr name, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params);
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, IntPtr name, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, IntPtr name, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, IntPtr name, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, IntPtr name, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, IntPtr name, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, Byte[] name, [Out] IntPtr @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, Byte[] name, [Out] IntPtr @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, Byte[] name, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, Byte[] name, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, Byte[] name, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, Byte[] name, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, ref Byte name, [Out] IntPtr @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, ref Byte name, [Out] IntPtr @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, ref Byte name, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, ref Byte name, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterfvNV(UInt32 id, Int32 len, ref Byte name, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramNamedParameterfvNV(Int32 id, Int32 len, ref Byte name, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, IntPtr name, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params);
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, IntPtr name, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, IntPtr name, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, IntPtr name, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, IntPtr name, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, IntPtr name, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, Byte[] name, [Out] IntPtr @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, Byte[] name, [Out] IntPtr @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, Byte[] name, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, Byte[] name, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, Byte[] name, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, Byte[] name, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = name)
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, ref Byte name, [Out] IntPtr @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, ref Byte name, [Out] IntPtr @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, ref Byte name, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, ref Byte name, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramNamedParameterdvNV(UInt32 id, Int32 len, ref Byte name, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramNamedParameterdvNV(Int32 id, Int32 len, ref Byte name, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Byte* name_ptr = &name)
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex2hNV(UInt16 x, UInt16 y)
        {
            Delegates.glVertex2hNV((UInt16)x, (UInt16)y);
        }

        public static 
        void glVertex2hNV(Int16 x, Int16 y)
        {
            Delegates.glVertex2hNV((UInt16)x, (UInt16)y);
        }

        public static 
        void glVertex2hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex2hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex2hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertex2hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex2hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex2hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertex2hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex2hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex2hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex3hNV(UInt16 x, UInt16 y, UInt16 z)
        {
            Delegates.glVertex3hNV((UInt16)x, (UInt16)y, (UInt16)z);
        }

        public static 
        void glVertex3hNV(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertex3hNV((UInt16)x, (UInt16)y, (UInt16)z);
        }

        public static 
        void glVertex3hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex3hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex3hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertex3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex3hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertex3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex3hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex4hNV(UInt16 x, UInt16 y, UInt16 z, UInt16 w)
        {
            Delegates.glVertex4hNV((UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
        }

        public static 
        void glVertex4hNV(Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertex4hNV((UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
        }

        public static 
        void glVertex4hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glVertex4hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex4hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertex4hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex4hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertex4hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertex4hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertex4hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex4hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormal3hNV(UInt16 nx, UInt16 ny, UInt16 nz)
        {
            Delegates.glNormal3hNV((UInt16)nx, (UInt16)ny, (UInt16)nz);
        }

        public static 
        void glNormal3hNV(Int16 nx, Int16 ny, Int16 nz)
        {
            Delegates.glNormal3hNV((UInt16)nx, (UInt16)ny, (UInt16)nz);
        }

        public static 
        void glNormal3hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glNormal3hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormal3hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glNormal3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glNormal3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormal3hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glNormal3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glNormal3hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glNormal3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3hNV(UInt16 red, UInt16 green, UInt16 blue)
        {
            Delegates.glColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glColor3hNV(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glColor3hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor3hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glColor3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glColor3hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor3hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glColor3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glColor3hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4hNV(UInt16 red, UInt16 green, UInt16 blue, UInt16 alpha)
        {
            Delegates.glColor4hNV((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
        }

        public static 
        void glColor4hNV(Int16 red, Int16 green, Int16 blue, Int16 alpha)
        {
            Delegates.glColor4hNV((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
        }

        public static 
        void glColor4hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glColor4hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glColor4hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glColor4hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor4hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glColor4hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glColor4hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glColor4hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor4hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord1hNV(UInt16 s)
        {
            Delegates.glTexCoord1hNV((UInt16)s);
        }

        public static 
        void glTexCoord1hNV(Int16 s)
        {
            Delegates.glTexCoord1hNV((UInt16)s);
        }

        public static 
        void glTexCoord1hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord1hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord1hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord1hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord1hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord2hNV(UInt16 s, UInt16 t)
        {
            Delegates.glTexCoord2hNV((UInt16)s, (UInt16)t);
        }

        public static 
        void glTexCoord2hNV(Int16 s, Int16 t)
        {
            Delegates.glTexCoord2hNV((UInt16)s, (UInt16)t);
        }

        public static 
        void glTexCoord2hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord2hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord2hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord2hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord2hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord3hNV(UInt16 s, UInt16 t, UInt16 r)
        {
            Delegates.glTexCoord3hNV((UInt16)s, (UInt16)t, (UInt16)r);
        }

        public static 
        void glTexCoord3hNV(Int16 s, Int16 t, Int16 r)
        {
            Delegates.glTexCoord3hNV((UInt16)s, (UInt16)t, (UInt16)r);
        }

        public static 
        void glTexCoord3hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord3hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord3hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord3hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord3hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord4hNV(UInt16 s, UInt16 t, UInt16 r, UInt16 q)
        {
            Delegates.glTexCoord4hNV((UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
        }

        public static 
        void glTexCoord4hNV(Int16 s, Int16 t, Int16 r, Int16 q)
        {
            Delegates.glTexCoord4hNV((UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
        }

        public static 
        void glTexCoord4hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glTexCoord4hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord4hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTexCoord4hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glTexCoord4hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord1hNV(int target, UInt16 s)
        {
            Delegates.glMultiTexCoord1hNV((int)target, (UInt16)s);
        }

        public static 
        void glMultiTexCoord1hNV(int target, Int16 s)
        {
            Delegates.glMultiTexCoord1hNV((int)target, (UInt16)s);
        }

        public static 
        void glMultiTexCoord1hvNV(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord1hvNV((int)target, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord1hvNV(int target, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1hvNV(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord1hvNV(int target, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord1hvNV(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord2hNV(int target, UInt16 s, UInt16 t)
        {
            Delegates.glMultiTexCoord2hNV((int)target, (UInt16)s, (UInt16)t);
        }

        public static 
        void glMultiTexCoord2hNV(int target, Int16 s, Int16 t)
        {
            Delegates.glMultiTexCoord2hNV((int)target, (UInt16)s, (UInt16)t);
        }

        public static 
        void glMultiTexCoord2hvNV(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord2hvNV((int)target, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord2hvNV(int target, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2hvNV(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord2hvNV(int target, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord2hvNV(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord3hNV(int target, UInt16 s, UInt16 t, UInt16 r)
        {
            Delegates.glMultiTexCoord3hNV((int)target, (UInt16)s, (UInt16)t, (UInt16)r);
        }

        public static 
        void glMultiTexCoord3hNV(int target, Int16 s, Int16 t, Int16 r)
        {
            Delegates.glMultiTexCoord3hNV((int)target, (UInt16)s, (UInt16)t, (UInt16)r);
        }

        public static 
        void glMultiTexCoord3hvNV(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord3hvNV((int)target, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord3hvNV(int target, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3hvNV(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord3hvNV(int target, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord3hvNV(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord4hNV(int target, UInt16 s, UInt16 t, UInt16 r, UInt16 q)
        {
            Delegates.glMultiTexCoord4hNV((int)target, (UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
        }

        public static 
        void glMultiTexCoord4hNV(int target, Int16 s, Int16 t, Int16 r, Int16 q)
        {
            Delegates.glMultiTexCoord4hNV((int)target, (UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
        }

        public static 
        void glMultiTexCoord4hvNV(int target, IntPtr v)
        {
            unsafe
            {
                Delegates.glMultiTexCoord4hvNV((int)target, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord4hvNV(int target, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4hvNV(int target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiTexCoord4hvNV(int target, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiTexCoord4hvNV(int target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4hvNV((int)target, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glFogCoordhNV(UInt16 fog)
        {
            Delegates.glFogCoordhNV((UInt16)fog);
        }

        public static 
        void glFogCoordhNV(Int16 fog)
        {
            Delegates.glFogCoordhNV((UInt16)fog);
        }

        public static 
        void glFogCoordhvNV(IntPtr fog)
        {
            unsafe
            {
                Delegates.glFogCoordhvNV((UInt16*)fog);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glFogCoordhvNV(UInt16[] fog)
        {
            unsafe
            {
                fixed (UInt16* fog_ptr = fog)
                {
                    Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
                }
            }
        }

        public static 
        void glFogCoordhvNV(Int16[] fog)
        {
            unsafe
            {
                fixed (Int16* fog_ptr = fog)
                {
                    Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glFogCoordhvNV(ref UInt16 fog)
        {
            unsafe
            {
                fixed (UInt16* fog_ptr = &fog)
                {
                    Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
                }
            }
        }

        public static 
        void glFogCoordhvNV(ref Int16 fog)
        {
            unsafe
            {
                fixed (Int16* fog_ptr = &fog)
                {
                    Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3hNV(UInt16 red, UInt16 green, UInt16 blue)
        {
            Delegates.glSecondaryColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glSecondaryColor3hNV(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glSecondaryColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void glSecondaryColor3hvNV(IntPtr v)
        {
            unsafe
            {
                Delegates.glSecondaryColor3hvNV((UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3hvNV(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3hvNV(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSecondaryColor3hvNV(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glSecondaryColor3hvNV(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexWeighthNV(UInt16 weight)
        {
            Delegates.glVertexWeighthNV((UInt16)weight);
        }

        public static 
        void glVertexWeighthNV(Int16 weight)
        {
            Delegates.glVertexWeighthNV((UInt16)weight);
        }

        public static 
        void glVertexWeighthvNV(IntPtr weight)
        {
            unsafe
            {
                Delegates.glVertexWeighthvNV((UInt16*)weight);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexWeighthvNV(UInt16[] weight)
        {
            unsafe
            {
                fixed (UInt16* weight_ptr = weight)
                {
                    Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
                }
            }
        }

        public static 
        void glVertexWeighthvNV(Int16[] weight)
        {
            unsafe
            {
                fixed (Int16* weight_ptr = weight)
                {
                    Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexWeighthvNV(ref UInt16 weight)
        {
            unsafe
            {
                fixed (UInt16* weight_ptr = &weight)
                {
                    Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
                }
            }
        }

        public static 
        void glVertexWeighthvNV(ref Int16 weight)
        {
            unsafe
            {
                fixed (Int16* weight_ptr = &weight)
                {
                    Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1hNV(UInt32 index, UInt16 x)
        {
            Delegates.glVertexAttrib1hNV((UInt32)index, (UInt16)x);
        }

        public static 
        void glVertexAttrib1hNV(Int32 index, Int16 x)
        {
            Delegates.glVertexAttrib1hNV((UInt32)index, (UInt16)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1hvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttrib1hvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1hvNV(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1hvNV(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib1hvNV(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib1hvNV(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2hNV(UInt32 index, UInt16 x, UInt16 y)
        {
            Delegates.glVertexAttrib2hNV((UInt32)index, (UInt16)x, (UInt16)y);
        }

        public static 
        void glVertexAttrib2hNV(Int32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2hNV((UInt32)index, (UInt16)x, (UInt16)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2hvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttrib2hvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2hvNV(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2hvNV(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib2hvNV(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib2hvNV(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3hNV(UInt32 index, UInt16 x, UInt16 y, UInt16 z)
        {
            Delegates.glVertexAttrib3hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z);
        }

        public static 
        void glVertexAttrib3hNV(Int32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3hvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttrib3hvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3hvNV(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3hvNV(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib3hvNV(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib3hvNV(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4hNV(UInt32 index, UInt16 x, UInt16 y, UInt16 z, UInt16 w)
        {
            Delegates.glVertexAttrib4hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
        }

        public static 
        void glVertexAttrib4hNV(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4hvNV(UInt32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttrib4hvNV(Int32 index, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4hvNV(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4hvNV(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttrib4hvNV(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttrib4hvNV(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1hvNV(UInt32 index, Int32 n, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttribs1hvNV(Int32 index, Int32 n, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1hvNV(UInt32 index, Int32 n, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs1hvNV(Int32 index, Int32 n, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs1hvNV(UInt32 index, Int32 n, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs1hvNV(Int32 index, Int32 n, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2hvNV(UInt32 index, Int32 n, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttribs2hvNV(Int32 index, Int32 n, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2hvNV(UInt32 index, Int32 n, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs2hvNV(Int32 index, Int32 n, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs2hvNV(UInt32 index, Int32 n, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs2hvNV(Int32 index, Int32 n, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3hvNV(UInt32 index, Int32 n, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttribs3hvNV(Int32 index, Int32 n, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3hvNV(UInt32 index, Int32 n, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs3hvNV(Int32 index, Int32 n, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs3hvNV(UInt32 index, Int32 n, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs3hvNV(Int32 index, Int32 n, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4hvNV(UInt32 index, Int32 n, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }
        }

        public static 
        void glVertexAttribs4hvNV(Int32 index, Int32 n, IntPtr v)
        {
            unsafe
            {
                Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4hvNV(UInt32 index, Int32 n, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4hvNV(Int32 index, Int32 n, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribs4hvNV(UInt32 index, Int32 n, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glVertexAttribs4hvNV(Int32 index, Int32 n, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void glPixelDataRangeNV(int target, Int32 length, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glPixelDataRangeNV((int)target, (Int32)length, (IntPtr)pointer);
            }
        }

        public static 
        void glPixelDataRangeNV(int target, Int32 length, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glPixelDataRangeNV((int)target, (Int32)length, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glFlushPixelDataRangeNV(int target)
        {
            Delegates.glFlushPixelDataRangeNV((int)target);
        }

        public static 
        void glPrimitiveRestartNV()
        {
            Delegates.glPrimitiveRestartNV();
        }

        [System.CLSCompliant(false)]
        public static 
        void glPrimitiveRestartIndexNV(UInt32 index)
        {
            Delegates.glPrimitiveRestartIndexNV((UInt32)index);
        }

        public static 
        void glPrimitiveRestartIndexNV(Int32 index)
        {
            Delegates.glPrimitiveRestartIndexNV((UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameterI4iNV(int target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glProgramLocalParameterI4iNV((int)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void glProgramLocalParameterI4iNV(int target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glProgramLocalParameterI4iNV((int)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameterI4ivNV(int target, UInt32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params);
            }
        }

        public static 
        void glProgramLocalParameterI4ivNV(int target, Int32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameterI4ivNV(int target, UInt32 index, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameterI4ivNV(int target, Int32 index, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameterI4ivNV(int target, UInt32 index, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameterI4ivNV(int target, Int32 index, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParametersI4ivNV(int target, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params);
            }
        }

        public static 
        void glProgramLocalParametersI4ivNV(int target, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParametersI4ivNV(int target, UInt32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParametersI4ivNV(int target, Int32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParametersI4ivNV(int target, UInt32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParametersI4ivNV(int target, Int32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameterI4uiNV(int target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
        {
            Delegates.glProgramLocalParameterI4uiNV((int)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
        }

        public static 
        void glProgramLocalParameterI4uiNV(int target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glProgramLocalParameterI4uiNV((int)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameterI4uivNV(int target, UInt32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params);
            }
        }

        public static 
        void glProgramLocalParameterI4uivNV(int target, Int32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameterI4uivNV(int target, UInt32 index, UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameterI4uivNV(int target, Int32 index, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParameterI4uivNV(int target, UInt32 index, ref UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParameterI4uivNV(int target, Int32 index, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParametersI4uivNV(int target, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params);
            }
        }

        public static 
        void glProgramLocalParametersI4uivNV(int target, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramLocalParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParametersI4uivNV(int target, UInt32 index, Int32 count, UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParametersI4uivNV(int target, Int32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramLocalParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramLocalParametersI4uivNV(int target, UInt32 index, Int32 count, ref UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramLocalParametersI4uivNV(int target, Int32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramLocalParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameterI4iNV(int target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glProgramEnvParameterI4iNV((int)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void glProgramEnvParameterI4iNV(int target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glProgramEnvParameterI4iNV((int)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameterI4ivNV(int target, UInt32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params);
            }
        }

        public static 
        void glProgramEnvParameterI4ivNV(int target, Int32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameterI4ivNV(int target, UInt32 index, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameterI4ivNV(int target, Int32 index, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameterI4ivNV(int target, UInt32 index, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameterI4ivNV(int target, Int32 index, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameterI4ivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParametersI4ivNV(int target, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params);
            }
        }

        public static 
        void glProgramEnvParametersI4ivNV(int target, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParametersI4ivNV(int target, UInt32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParametersI4ivNV(int target, Int32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParametersI4ivNV(int target, UInt32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParametersI4ivNV(int target, Int32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParametersI4ivNV((int)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameterI4uiNV(int target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
        {
            Delegates.glProgramEnvParameterI4uiNV((int)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
        }

        public static 
        void glProgramEnvParameterI4uiNV(int target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glProgramEnvParameterI4uiNV((int)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameterI4uivNV(int target, UInt32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params);
            }
        }

        public static 
        void glProgramEnvParameterI4uivNV(int target, Int32 index, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameterI4uivNV(int target, UInt32 index, UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameterI4uivNV(int target, Int32 index, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParameterI4uivNV(int target, UInt32 index, ref UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParameterI4uivNV(int target, Int32 index, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParameterI4uivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParametersI4uivNV(int target, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params);
            }
        }

        public static 
        void glProgramEnvParametersI4uivNV(int target, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramEnvParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParametersI4uivNV(int target, UInt32 index, Int32 count, UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParametersI4uivNV(int target, Int32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramEnvParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramEnvParametersI4uivNV(int target, UInt32 index, Int32 count, ref UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramEnvParametersI4uivNV(int target, Int32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramEnvParametersI4uivNV((int)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterIivNV(int target, UInt32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramLocalParameterIivNV((int)target, (UInt32)index, (Int32*)@params);
            }
        }

        public static 
        void glGetProgramLocalParameterIivNV(int target, Int32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramLocalParameterIivNV((int)target, (UInt32)index, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterIivNV(int target, UInt32 index, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramLocalParameterIivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramLocalParameterIivNV(int target, Int32 index, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramLocalParameterIivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterIivNV(int target, UInt32 index, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramLocalParameterIivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramLocalParameterIivNV(int target, Int32 index, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramLocalParameterIivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterIuivNV(int target, UInt32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramLocalParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params);
            }
        }

        public static 
        void glGetProgramLocalParameterIuivNV(int target, Int32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramLocalParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterIuivNV(int target, UInt32 index, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetProgramLocalParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramLocalParameterIuivNV(int target, Int32 index, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramLocalParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramLocalParameterIuivNV(int target, UInt32 index, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramLocalParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramLocalParameterIuivNV(int target, Int32 index, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramLocalParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterIivNV(int target, UInt32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramEnvParameterIivNV((int)target, (UInt32)index, (Int32*)@params);
            }
        }

        public static 
        void glGetProgramEnvParameterIivNV(int target, Int32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramEnvParameterIivNV((int)target, (UInt32)index, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterIivNV(int target, UInt32 index, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramEnvParameterIivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramEnvParameterIivNV(int target, Int32 index, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramEnvParameterIivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterIivNV(int target, UInt32 index, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramEnvParameterIivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramEnvParameterIivNV(int target, Int32 index, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramEnvParameterIivNV((int)target, (UInt32)index, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterIuivNV(int target, UInt32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramEnvParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params);
            }
        }

        public static 
        void glGetProgramEnvParameterIuivNV(int target, Int32 index, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetProgramEnvParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterIuivNV(int target, UInt32 index, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetProgramEnvParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetProgramEnvParameterIuivNV(int target, Int32 index, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramEnvParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetProgramEnvParameterIuivNV(int target, UInt32 index, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramEnvParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetProgramEnvParameterIuivNV(int target, Int32 index, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramEnvParameterIuivNV((int)target, (UInt32)index, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glProgramVertexLimitNV(int target, Int32 limit)
        {
            Delegates.glProgramVertexLimitNV((int)target, (Int32)limit);
        }

        public static 
        void glDepthRangedNV(Double zNear, Double zFar)
        {
            Delegates.glDepthRangedNV((Double)zNear, (Double)zFar);
        }

        public static 
        void glClearDepthdNV(Double depth)
        {
            Delegates.glClearDepthdNV((Double)depth);
        }

        public static 
        void glDepthBoundsdNV(Double zmin, Double zmax)
        {
            Delegates.glDepthBoundsdNV((Double)zmin, (Double)zmax);
        }

        public static 
        void glRenderbufferStorageMultisampleCoverageNV(int target, Int32 coverageSamples, Int32 colorSamples, int internalformat, Int32 width, Int32 height)
        {
            Delegates.glRenderbufferStorageMultisampleCoverageNV((int)target, (Int32)coverageSamples, (Int32)colorSamples, (int)internalformat, (Int32)width, (Int32)height);
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersfvNV(int target, UInt32 buffer, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramBufferParametersfvNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params);
            }
        }

        public static 
        void glProgramBufferParametersfvNV(int target, Int32 buffer, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramBufferParametersfvNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersfvNV(int target, UInt32 buffer, UInt32 index, Int32 count, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramBufferParametersfvNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramBufferParametersfvNV(int target, Int32 buffer, Int32 index, Int32 count, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glProgramBufferParametersfvNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersfvNV(int target, UInt32 buffer, UInt32 index, Int32 count, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramBufferParametersfvNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramBufferParametersfvNV(int target, Int32 buffer, Int32 index, Int32 count, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glProgramBufferParametersfvNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersIivNV(int target, UInt32 buffer, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramBufferParametersIivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params);
            }
        }

        public static 
        void glProgramBufferParametersIivNV(int target, Int32 buffer, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramBufferParametersIivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersIivNV(int target, UInt32 buffer, UInt32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramBufferParametersIivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramBufferParametersIivNV(int target, Int32 buffer, Int32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramBufferParametersIivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersIivNV(int target, UInt32 buffer, UInt32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramBufferParametersIivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramBufferParametersIivNV(int target, Int32 buffer, Int32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramBufferParametersIivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersIuivNV(int target, UInt32 buffer, UInt32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramBufferParametersIuivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params);
            }
        }

        public static 
        void glProgramBufferParametersIuivNV(int target, Int32 buffer, Int32 index, Int32 count, IntPtr @params)
        {
            unsafe
            {
                Delegates.glProgramBufferParametersIuivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersIuivNV(int target, UInt32 buffer, UInt32 index, Int32 count, UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glProgramBufferParametersIuivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramBufferParametersIuivNV(int target, Int32 buffer, Int32 index, Int32 count, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glProgramBufferParametersIuivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glProgramBufferParametersIuivNV(int target, UInt32 buffer, UInt32 index, Int32 count, ref UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glProgramBufferParametersIuivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glProgramBufferParametersIuivNV(int target, Int32 buffer, Int32 index, Int32 count, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glProgramBufferParametersIuivNV((int)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void glBeginTransformFeedbackNV(int primitiveMode)
        {
            Delegates.glBeginTransformFeedbackNV((int)primitiveMode);
        }

        public static 
        void glEndTransformFeedbackNV()
        {
            Delegates.glEndTransformFeedbackNV();
        }

        [System.CLSCompliant(false)]
        public static 
        void glTransformFeedbackAttribsNV(UInt32 count, IntPtr attribs, int bufferMode)
        {
            unsafe
            {
                Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs, (int)bufferMode);
            }
        }

        public static 
        void glTransformFeedbackAttribsNV(Int32 count, IntPtr attribs, int bufferMode)
        {
            unsafe
            {
                Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs, (int)bufferMode);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTransformFeedbackAttribsNV(UInt32 count, Int32[] attribs, int bufferMode)
        {
            unsafe
            {
                fixed (Int32* attribs_ptr = attribs)
                {
                    Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (int)bufferMode);
                }
            }
        }

        public static 
        void glTransformFeedbackAttribsNV(Int32 count, Int32[] attribs, int bufferMode)
        {
            unsafe
            {
                fixed (Int32* attribs_ptr = attribs)
                {
                    Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (int)bufferMode);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTransformFeedbackAttribsNV(UInt32 count, ref Int32 attribs, int bufferMode)
        {
            unsafe
            {
                fixed (Int32* attribs_ptr = &attribs)
                {
                    Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (int)bufferMode);
                }
            }
        }

        public static 
        void glTransformFeedbackAttribsNV(Int32 count, ref Int32 attribs, int bufferMode)
        {
            unsafe
            {
                fixed (Int32* attribs_ptr = &attribs)
                {
                    Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (int)bufferMode);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindBufferRangeNV(int target, UInt32 index, UInt32 buffer, IntPtr offset, IntPtr size)
        {
            Delegates.glBindBufferRangeNV((int)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset, (IntPtr)size);
        }

        public static 
        void glBindBufferRangeNV(int target, Int32 index, Int32 buffer, IntPtr offset, IntPtr size)
        {
            Delegates.glBindBufferRangeNV((int)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset, (IntPtr)size);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindBufferOffsetNV(int target, UInt32 index, UInt32 buffer, IntPtr offset)
        {
            Delegates.glBindBufferOffsetNV((int)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset);
        }

        public static 
        void glBindBufferOffsetNV(int target, Int32 index, Int32 buffer, IntPtr offset)
        {
            Delegates.glBindBufferOffsetNV((int)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindBufferBaseNV(int target, UInt32 index, UInt32 buffer)
        {
            Delegates.glBindBufferBaseNV((int)target, (UInt32)index, (UInt32)buffer);
        }

        public static 
        void glBindBufferBaseNV(int target, Int32 index, Int32 buffer)
        {
            Delegates.glBindBufferBaseNV((int)target, (UInt32)index, (UInt32)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void glTransformFeedbackVaryingsNV(UInt32 program, Int32 count, IntPtr locations, int bufferMode)
        {
            unsafe
            {
                Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations, (int)bufferMode);
            }
        }

        public static 
        void glTransformFeedbackVaryingsNV(Int32 program, Int32 count, IntPtr locations, int bufferMode)
        {
            unsafe
            {
                Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations, (int)bufferMode);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTransformFeedbackVaryingsNV(UInt32 program, Int32 count, Int32[] locations, int bufferMode)
        {
            unsafe
            {
                fixed (Int32* locations_ptr = locations)
                {
                    Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (int)bufferMode);
                }
            }
        }

        public static 
        void glTransformFeedbackVaryingsNV(Int32 program, Int32 count, Int32[] locations, int bufferMode)
        {
            unsafe
            {
                fixed (Int32* locations_ptr = locations)
                {
                    Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (int)bufferMode);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTransformFeedbackVaryingsNV(UInt32 program, Int32 count, ref Int32 locations, int bufferMode)
        {
            unsafe
            {
                fixed (Int32* locations_ptr = &locations)
                {
                    Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (int)bufferMode);
                }
            }
        }

        public static 
        void glTransformFeedbackVaryingsNV(Int32 program, Int32 count, ref Int32 locations, int bufferMode)
        {
            unsafe
            {
                fixed (Int32* locations_ptr = &locations)
                {
                    Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (int)bufferMode);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glActiveVaryingNV(UInt32 program, System.String name)
        {
            Delegates.glActiveVaryingNV((UInt32)program, (System.String)name);
        }

        public static 
        void glActiveVaryingNV(Int32 program, System.String name)
        {
            Delegates.glActiveVaryingNV((UInt32)program, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGetVaryingLocationNV(UInt32 program, System.String name)
        {
            return Delegates.glGetVaryingLocationNV((UInt32)program, (System.String)name);
        }

        public static 
        Int32 glGetVaryingLocationNV(Int32 program, System.String name)
        {
            return Delegates.glGetVaryingLocationNV((UInt32)program, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] IntPtr length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] IntPtr size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] Int32[] size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] IntPtr type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] int[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetActiveVaryingNV(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void glGetActiveVaryingNV(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out int type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (int* type_ptr = &type)
                {
                    Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (int*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetTransformFeedbackVaryingNV(UInt32 program, UInt32 index, [Out] IntPtr location)
        {
            unsafe
            {
                Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location);
            }
        }

        public static 
        void glGetTransformFeedbackVaryingNV(Int32 program, Int32 index, [Out] IntPtr location)
        {
            unsafe
            {
                Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetTransformFeedbackVaryingNV(UInt32 program, UInt32 index, [Out] Int32[] location)
        {
            unsafe
            {
                fixed (Int32* location_ptr = location)
                {
                    Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
                }
            }
        }

        public static 
        void glGetTransformFeedbackVaryingNV(Int32 program, Int32 index, [Out] Int32[] location)
        {
            unsafe
            {
                fixed (Int32* location_ptr = location)
                {
                    Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetTransformFeedbackVaryingNV(UInt32 program, UInt32 index, [Out] out Int32 location)
        {
            unsafe
            {
                fixed (Int32* location_ptr = &location)
                {
                    Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
                    location = *location_ptr;
                }
            }
        }

        public static 
        void glGetTransformFeedbackVaryingNV(Int32 program, Int32 index, [Out] out Int32 location)
        {
            unsafe
            {
                fixed (Int32* location_ptr = &location)
                {
                    Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
                    location = *location_ptr;
                }
            }
        }

        public static 
        void glResizeBuffersMESA()
        {
            Delegates.glResizeBuffersMESA();
        }

        public static 
        void glWindowPos2dMESA(Double x, Double y)
        {
            Delegates.glWindowPos2dMESA((Double)x, (Double)y);
        }

        public static 
        void glWindowPos2dvMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2dvMESA((Double*)v);
            }
        }

        public static 
        void glWindowPos2dvMESA(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos2dvMESA((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2dvMESA(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos2dvMESA((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2fMESA(Single x, Single y)
        {
            Delegates.glWindowPos2fMESA((Single)x, (Single)y);
        }

        public static 
        void glWindowPos2fvMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2fvMESA((Single*)v);
            }
        }

        public static 
        void glWindowPos2fvMESA(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos2fvMESA((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2fvMESA(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos2fvMESA((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2iMESA(Int32 x, Int32 y)
        {
            Delegates.glWindowPos2iMESA((Int32)x, (Int32)y);
        }

        public static 
        void glWindowPos2ivMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2ivMESA((Int32*)v);
            }
        }

        public static 
        void glWindowPos2ivMESA(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos2ivMESA((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2ivMESA(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos2ivMESA((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2sMESA(Int16 x, Int16 y)
        {
            Delegates.glWindowPos2sMESA((Int16)x, (Int16)y);
        }

        public static 
        void glWindowPos2svMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos2svMESA((Int16*)v);
            }
        }

        public static 
        void glWindowPos2svMESA(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos2svMESA((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos2svMESA(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos2svMESA((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3dMESA(Double x, Double y, Double z)
        {
            Delegates.glWindowPos3dMESA((Double)x, (Double)y, (Double)z);
        }

        public static 
        void glWindowPos3dvMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3dvMESA((Double*)v);
            }
        }

        public static 
        void glWindowPos3dvMESA(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos3dvMESA((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3dvMESA(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos3dvMESA((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3fMESA(Single x, Single y, Single z)
        {
            Delegates.glWindowPos3fMESA((Single)x, (Single)y, (Single)z);
        }

        public static 
        void glWindowPos3fvMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3fvMESA((Single*)v);
            }
        }

        public static 
        void glWindowPos3fvMESA(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos3fvMESA((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3fvMESA(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos3fvMESA((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3iMESA(Int32 x, Int32 y, Int32 z)
        {
            Delegates.glWindowPos3iMESA((Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void glWindowPos3ivMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3ivMESA((Int32*)v);
            }
        }

        public static 
        void glWindowPos3ivMESA(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos3ivMESA((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3ivMESA(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos3ivMESA((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3sMESA(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glWindowPos3sMESA((Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glWindowPos3svMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos3svMESA((Int16*)v);
            }
        }

        public static 
        void glWindowPos3svMESA(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos3svMESA((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos3svMESA(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos3svMESA((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos4dMESA(Double x, Double y, Double z, Double w)
        {
            Delegates.glWindowPos4dMESA((Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glWindowPos4dvMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos4dvMESA((Double*)v);
            }
        }

        public static 
        void glWindowPos4dvMESA(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos4dvMESA((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos4dvMESA(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos4dvMESA((Double*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos4fMESA(Single x, Single y, Single z, Single w)
        {
            Delegates.glWindowPos4fMESA((Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glWindowPos4fvMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos4fvMESA((Single*)v);
            }
        }

        public static 
        void glWindowPos4fvMESA(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos4fvMESA((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos4fvMESA(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos4fvMESA((Single*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos4iMESA(Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glWindowPos4iMESA((Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void glWindowPos4ivMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos4ivMESA((Int32*)v);
            }
        }

        public static 
        void glWindowPos4ivMESA(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos4ivMESA((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos4ivMESA(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos4ivMESA((Int32*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos4sMESA(Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glWindowPos4sMESA((Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void glWindowPos4svMESA(IntPtr v)
        {
            unsafe
            {
                Delegates.glWindowPos4svMESA((Int16*)v);
            }
        }

        public static 
        void glWindowPos4svMESA(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos4svMESA((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glWindowPos4svMESA(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos4svMESA((Int16*)v_ptr);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, IntPtr first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first, (Int32*)count, (Int32)primcount, (Int32)modestride);
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, IntPtr first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, IntPtr first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, Int32[] first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, Int32[] first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, Int32[] first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, ref Int32 first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, ref Int32 first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(IntPtr mode, ref Int32 first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, IntPtr first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first, (Int32*)count, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, IntPtr first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, IntPtr first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, Int32[] first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* first_ptr = first)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, Int32[] first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, Int32[] first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, ref Int32 first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* first_ptr = &first)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, ref Int32 first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(int[] mode, ref Int32 first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, IntPtr first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first, (Int32*)count, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, IntPtr first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, IntPtr first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, Int32[] first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* first_ptr = first)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, Int32[] first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, Int32[] first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, ref Int32 first, IntPtr count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* first_ptr = &first)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, ref Int32 first, Int32[] count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawArraysIBM(ref int mode, ref Int32 first, ref Int32 count, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawArraysIBM((int*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(IntPtr mode, IntPtr count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                Delegates.glMultiModeDrawElementsIBM((int*)mode, (Int32*)count, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(IntPtr mode, IntPtr count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode, (Int32*)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(IntPtr mode, Int32[] count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(IntPtr mode, Int32[] count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((int*)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(IntPtr mode, ref Int32 count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(IntPtr mode, ref Int32 count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((int*)mode, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(int[] mode, IntPtr count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(int[] mode, IntPtr count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(int[] mode, Int32[] count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(int[] mode, Int32[] count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* count_ptr = count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(int[] mode, ref Int32 count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(int[] mode, ref Int32 count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = mode)
                fixed (Int32* count_ptr = &count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(ref int mode, IntPtr count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(ref int mode, IntPtr count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(ref int mode, Int32[] count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(ref int mode, Int32[] count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* count_ptr = count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(ref int mode, ref Int32 count, int type, IntPtr indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count_ptr, (int)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                }
            }
        }

        public static 
        void glMultiModeDrawElementsIBM(ref int mode, ref Int32 count, int type, [In, Out] object indices, Int32 primcount, Int32 modestride)
        {
            unsafe
            {
                fixed (int* mode_ptr = &mode)
                fixed (Int32* count_ptr = &count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiModeDrawElementsIBM((int*)mode_ptr, (Int32*)count_ptr, (int)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void glColorPointerListIBM(Int32 size, int type, Int32 stride, IntPtr pointer, Int32 ptrstride)
        {
            unsafe
            {
                Delegates.glColorPointerListIBM((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }
        }

        public static 
        void glColorPointerListIBM(Int32 size, int type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorPointerListIBM((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glSecondaryColorPointerListIBM(Int32 size, int type, Int32 stride, IntPtr pointer, Int32 ptrstride)
        {
            unsafe
            {
                Delegates.glSecondaryColorPointerListIBM((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }
        }

        public static 
        void glSecondaryColorPointerListIBM(Int32 size, int type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSecondaryColorPointerListIBM((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glEdgeFlagPointerListIBM(Int32 stride, IntPtr pointer, Int32 ptrstride)
        {
            unsafe
            {
                Delegates.glEdgeFlagPointerListIBM((Int32)stride, (Int32*)pointer, (Int32)ptrstride);
            }
        }

        public static 
        void glEdgeFlagPointerListIBM(Int32 stride, Int32[] pointer, Int32 ptrstride)
        {
            unsafe
            {
                fixed (Int32* pointer_ptr = pointer)
                {
                    Delegates.glEdgeFlagPointerListIBM((Int32)stride, (Int32*)pointer_ptr, (Int32)ptrstride);
                }
            }
        }

        public static 
        void glEdgeFlagPointerListIBM(Int32 stride, ref Int32 pointer, Int32 ptrstride)
        {
            unsafe
            {
                fixed (Int32* pointer_ptr = &pointer)
                {
                    Delegates.glEdgeFlagPointerListIBM((Int32)stride, (Int32*)pointer_ptr, (Int32)ptrstride);
                }
            }
        }

        public static 
        void glFogCoordPointerListIBM(int type, Int32 stride, IntPtr pointer, Int32 ptrstride)
        {
            unsafe
            {
                Delegates.glFogCoordPointerListIBM((int)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }
        }

        public static 
        void glFogCoordPointerListIBM(int type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glFogCoordPointerListIBM((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glIndexPointerListIBM(int type, Int32 stride, IntPtr pointer, Int32 ptrstride)
        {
            unsafe
            {
                Delegates.glIndexPointerListIBM((int)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }
        }

        public static 
        void glIndexPointerListIBM(int type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glIndexPointerListIBM((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glNormalPointerListIBM(int type, Int32 stride, IntPtr pointer, Int32 ptrstride)
        {
            unsafe
            {
                Delegates.glNormalPointerListIBM((int)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }
        }

        public static 
        void glNormalPointerListIBM(int type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glNormalPointerListIBM((int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glTexCoordPointerListIBM(Int32 size, int type, Int32 stride, IntPtr pointer, Int32 ptrstride)
        {
            unsafe
            {
                Delegates.glTexCoordPointerListIBM((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }
        }

        public static 
        void glTexCoordPointerListIBM(Int32 size, int type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexCoordPointerListIBM((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexPointerListIBM(Int32 size, int type, Int32 stride, IntPtr pointer, Int32 ptrstride)
        {
            unsafe
            {
                Delegates.glVertexPointerListIBM((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }
        }

        public static 
        void glVertexPointerListIBM(Int32 size, int type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexPointerListIBM((Int32)size, (int)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glTbufferMask3DFX(UInt32 mask)
        {
            Delegates.glTbufferMask3DFX((UInt32)mask);
        }

        public static 
        void glTbufferMask3DFX(Int32 mask)
        {
            Delegates.glTbufferMask3DFX((UInt32)mask);
        }

        public static 
        void glTexBumpParameterivATI(int pname, IntPtr param)
        {
            unsafe
            {
                Delegates.glTexBumpParameterivATI((int)pname, (Int32*)param);
            }
        }

        public static 
        void glTexBumpParameterivATI(int pname, Int32[] param)
        {
            unsafe
            {
                fixed (Int32* param_ptr = param)
                {
                    Delegates.glTexBumpParameterivATI((int)pname, (Int32*)param_ptr);
                }
            }
        }

        public static 
        void glTexBumpParameterivATI(int pname, ref Int32 param)
        {
            unsafe
            {
                fixed (Int32* param_ptr = &param)
                {
                    Delegates.glTexBumpParameterivATI((int)pname, (Int32*)param_ptr);
                }
            }
        }

        public static 
        void glTexBumpParameterfvATI(int pname, IntPtr param)
        {
            unsafe
            {
                Delegates.glTexBumpParameterfvATI((int)pname, (Single*)param);
            }
        }

        public static 
        void glTexBumpParameterfvATI(int pname, Single[] param)
        {
            unsafe
            {
                fixed (Single* param_ptr = param)
                {
                    Delegates.glTexBumpParameterfvATI((int)pname, (Single*)param_ptr);
                }
            }
        }

        public static 
        void glTexBumpParameterfvATI(int pname, ref Single param)
        {
            unsafe
            {
                fixed (Single* param_ptr = &param)
                {
                    Delegates.glTexBumpParameterfvATI((int)pname, (Single*)param_ptr);
                }
            }
        }

        public static 
        void glGetTexBumpParameterivATI(int pname, [Out] IntPtr param)
        {
            unsafe
            {
                Delegates.glGetTexBumpParameterivATI((int)pname, (Int32*)param);
            }
        }

        public static 
        void glGetTexBumpParameterivATI(int pname, [Out] Int32[] param)
        {
            unsafe
            {
                fixed (Int32* param_ptr = param)
                {
                    Delegates.glGetTexBumpParameterivATI((int)pname, (Int32*)param_ptr);
                }
            }
        }

        public static 
        void glGetTexBumpParameterivATI(int pname, [Out] out Int32 param)
        {
            unsafe
            {
                fixed (Int32* param_ptr = &param)
                {
                    Delegates.glGetTexBumpParameterivATI((int)pname, (Int32*)param_ptr);
                    param = *param_ptr;
                }
            }
        }

        public static 
        void glGetTexBumpParameterfvATI(int pname, [Out] IntPtr param)
        {
            unsafe
            {
                Delegates.glGetTexBumpParameterfvATI((int)pname, (Single*)param);
            }
        }

        public static 
        void glGetTexBumpParameterfvATI(int pname, [Out] Single[] param)
        {
            unsafe
            {
                fixed (Single* param_ptr = param)
                {
                    Delegates.glGetTexBumpParameterfvATI((int)pname, (Single*)param_ptr);
                }
            }
        }

        public static 
        void glGetTexBumpParameterfvATI(int pname, [Out] out Single param)
        {
            unsafe
            {
                fixed (Single* param_ptr = &param)
                {
                    Delegates.glGetTexBumpParameterfvATI((int)pname, (Single*)param_ptr);
                    param = *param_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glGenFragmentShadersATI(UInt32 range)
        {
            return Delegates.glGenFragmentShadersATI((UInt32)range);
        }

        public static 
        Int32 glGenFragmentShadersATI(Int32 range)
        {
            return Delegates.glGenFragmentShadersATI((UInt32)range);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindFragmentShaderATI(UInt32 id)
        {
            Delegates.glBindFragmentShaderATI((UInt32)id);
        }

        public static 
        void glBindFragmentShaderATI(Int32 id)
        {
            Delegates.glBindFragmentShaderATI((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteFragmentShaderATI(UInt32 id)
        {
            Delegates.glDeleteFragmentShaderATI((UInt32)id);
        }

        public static 
        void glDeleteFragmentShaderATI(Int32 id)
        {
            Delegates.glDeleteFragmentShaderATI((UInt32)id);
        }

        public static 
        void glBeginFragmentShaderATI()
        {
            Delegates.glBeginFragmentShaderATI();
        }

        public static 
        void glEndFragmentShaderATI()
        {
            Delegates.glEndFragmentShaderATI();
        }

        [System.CLSCompliant(false)]
        public static 
        void glPassTexCoordATI(UInt32 dst, UInt32 coord, int swizzle)
        {
            Delegates.glPassTexCoordATI((UInt32)dst, (UInt32)coord, (int)swizzle);
        }

        public static 
        void glPassTexCoordATI(Int32 dst, Int32 coord, int swizzle)
        {
            Delegates.glPassTexCoordATI((UInt32)dst, (UInt32)coord, (int)swizzle);
        }

        [System.CLSCompliant(false)]
        public static 
        void glSampleMapATI(UInt32 dst, UInt32 interp, int swizzle)
        {
            Delegates.glSampleMapATI((UInt32)dst, (UInt32)interp, (int)swizzle);
        }

        public static 
        void glSampleMapATI(Int32 dst, Int32 interp, int swizzle)
        {
            Delegates.glSampleMapATI((UInt32)dst, (UInt32)interp, (int)swizzle);
        }

        [System.CLSCompliant(false)]
        public static 
        void glColorFragmentOp1ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod)
        {
            Delegates.glColorFragmentOp1ATI((int)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
        }

        public static 
        void glColorFragmentOp1ATI(int op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
        {
            Delegates.glColorFragmentOp1ATI((int)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
        }

        [System.CLSCompliant(false)]
        public static 
        void glColorFragmentOp2ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod)
        {
            Delegates.glColorFragmentOp2ATI((int)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
        }

        public static 
        void glColorFragmentOp2ATI(int op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod)
        {
            Delegates.glColorFragmentOp2ATI((int)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
        }

        [System.CLSCompliant(false)]
        public static 
        void glColorFragmentOp3ATI(int op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod)
        {
            Delegates.glColorFragmentOp3ATI((int)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
        }

        public static 
        void glColorFragmentOp3ATI(int op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod, Int32 arg3, Int32 arg3Rep, Int32 arg3Mod)
        {
            Delegates.glColorFragmentOp3ATI((int)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
        }

        [System.CLSCompliant(false)]
        public static 
        void glAlphaFragmentOp1ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod)
        {
            Delegates.glAlphaFragmentOp1ATI((int)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
        }

        public static 
        void glAlphaFragmentOp1ATI(int op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
        {
            Delegates.glAlphaFragmentOp1ATI((int)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
        }

        [System.CLSCompliant(false)]
        public static 
        void glAlphaFragmentOp2ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod)
        {
            Delegates.glAlphaFragmentOp2ATI((int)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
        }

        public static 
        void glAlphaFragmentOp2ATI(int op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod)
        {
            Delegates.glAlphaFragmentOp2ATI((int)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
        }

        [System.CLSCompliant(false)]
        public static 
        void glAlphaFragmentOp3ATI(int op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod)
        {
            Delegates.glAlphaFragmentOp3ATI((int)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
        }

        public static 
        void glAlphaFragmentOp3ATI(int op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod, Int32 arg3, Int32 arg3Rep, Int32 arg3Mod)
        {
            Delegates.glAlphaFragmentOp3ATI((int)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetFragmentShaderConstantATI(UInt32 dst, IntPtr value)
        {
            unsafe
            {
                Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value);
            }
        }

        public static 
        void glSetFragmentShaderConstantATI(Int32 dst, IntPtr value)
        {
            unsafe
            {
                Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetFragmentShaderConstantATI(UInt32 dst, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glSetFragmentShaderConstantATI(Int32 dst, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetFragmentShaderConstantATI(UInt32 dst, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glSetFragmentShaderConstantATI(Int32 dst, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
                }
            }
        }

        public static 
        void glPNTrianglesiATI(int pname, Int32 param)
        {
            Delegates.glPNTrianglesiATI((int)pname, (Int32)param);
        }

        public static 
        void glPNTrianglesfATI(int pname, Single param)
        {
            Delegates.glPNTrianglesfATI((int)pname, (Single)param);
        }

        public static 
        Int32 glNewObjectBufferATI(Int32 size, IntPtr pointer, int usage)
        {
            unsafe
            {
                return Delegates.glNewObjectBufferATI((Int32)size, (IntPtr)pointer, (int)usage);
            }
        }

        public static 
        Int32 glNewObjectBufferATI(Int32 size, [In, Out] object pointer, int usage)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    return Delegates.glNewObjectBufferATI((Int32)size, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (int)usage);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsObjectBufferATI(UInt32 buffer)
        {
            return Delegates.glIsObjectBufferATI((UInt32)buffer);
        }

        public static 
        Int32 glIsObjectBufferATI(Int32 buffer)
        {
            return Delegates.glIsObjectBufferATI((UInt32)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void glUpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, IntPtr pointer, int preserve)
        {
            unsafe
            {
                Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (IntPtr)pointer, (int)preserve);
            }
        }

        public static 
        void glUpdateObjectBufferATI(Int32 buffer, Int32 offset, Int32 size, IntPtr pointer, int preserve)
        {
            unsafe
            {
                Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (IntPtr)pointer, (int)preserve);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glUpdateObjectBufferATI(UInt32 buffer, UInt32 offset, Int32 size, [In, Out] object pointer, int preserve)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (int)preserve);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glUpdateObjectBufferATI(Int32 buffer, Int32 offset, Int32 size, [In, Out] object pointer, int preserve)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (int)preserve);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectBufferfvATI(UInt32 buffer, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetObjectBufferfvATI((UInt32)buffer, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetObjectBufferfvATI(Int32 buffer, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetObjectBufferfvATI((UInt32)buffer, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectBufferfvATI(UInt32 buffer, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetObjectBufferfvATI((UInt32)buffer, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetObjectBufferfvATI(Int32 buffer, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetObjectBufferfvATI((UInt32)buffer, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectBufferfvATI(UInt32 buffer, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetObjectBufferfvATI((UInt32)buffer, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetObjectBufferfvATI(Int32 buffer, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetObjectBufferfvATI((UInt32)buffer, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectBufferivATI(UInt32 buffer, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetObjectBufferivATI((UInt32)buffer, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetObjectBufferivATI(Int32 buffer, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetObjectBufferivATI((UInt32)buffer, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectBufferivATI(UInt32 buffer, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetObjectBufferivATI((UInt32)buffer, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetObjectBufferivATI(Int32 buffer, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetObjectBufferivATI((UInt32)buffer, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetObjectBufferivATI(UInt32 buffer, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetObjectBufferivATI((UInt32)buffer, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetObjectBufferivATI(Int32 buffer, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetObjectBufferivATI((UInt32)buffer, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glFreeObjectBufferATI(UInt32 buffer)
        {
            Delegates.glFreeObjectBufferATI((UInt32)buffer);
        }

        public static 
        void glFreeObjectBufferATI(Int32 buffer)
        {
            Delegates.glFreeObjectBufferATI((UInt32)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void glArrayObjectATI(int array, Int32 size, int type, Int32 stride, UInt32 buffer, UInt32 offset)
        {
            Delegates.glArrayObjectATI((int)array, (Int32)size, (int)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
        }

        public static 
        void glArrayObjectATI(int array, Int32 size, int type, Int32 stride, Int32 buffer, Int32 offset)
        {
            Delegates.glArrayObjectATI((int)array, (Int32)size, (int)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
        }

        public static 
        void glGetArrayObjectfvATI(int array, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetArrayObjectfvATI((int)array, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetArrayObjectfvATI(int array, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetArrayObjectfvATI((int)array, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetArrayObjectfvATI(int array, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetArrayObjectfvATI((int)array, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetArrayObjectivATI(int array, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetArrayObjectivATI((int)array, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetArrayObjectivATI(int array, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetArrayObjectivATI((int)array, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetArrayObjectivATI(int array, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetArrayObjectivATI((int)array, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glVariantArrayObjectATI(UInt32 id, int type, Int32 stride, UInt32 buffer, UInt32 offset)
        {
            Delegates.glVariantArrayObjectATI((UInt32)id, (int)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
        }

        public static 
        void glVariantArrayObjectATI(Int32 id, int type, Int32 stride, Int32 buffer, Int32 offset)
        {
            Delegates.glVariantArrayObjectATI((UInt32)id, (int)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantArrayObjectfvATI(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetVariantArrayObjectfvATI(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantArrayObjectfvATI(UInt32 id, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVariantArrayObjectfvATI(Int32 id, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantArrayObjectfvATI(UInt32 id, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVariantArrayObjectfvATI(Int32 id, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantArrayObjectivATI(UInt32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVariantArrayObjectivATI((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetVariantArrayObjectivATI(Int32 id, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVariantArrayObjectivATI((UInt32)id, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantArrayObjectivATI(UInt32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVariantArrayObjectivATI((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVariantArrayObjectivATI(Int32 id, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVariantArrayObjectivATI((UInt32)id, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVariantArrayObjectivATI(UInt32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVariantArrayObjectivATI((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVariantArrayObjectivATI(Int32 id, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVariantArrayObjectivATI((UInt32)id, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glVertexStream1sATI(int stream, Int16 x)
        {
            Delegates.glVertexStream1sATI((int)stream, (Int16)x);
        }

        public static 
        void glVertexStream1svATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream1svATI((int)stream, (Int16*)coords);
            }
        }

        public static 
        void glVertexStream1svATI(int stream, Int16[] coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = coords)
                {
                    Delegates.glVertexStream1svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream1svATI(int stream, ref Int16 coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = &coords)
                {
                    Delegates.glVertexStream1svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream1iATI(int stream, Int32 x)
        {
            Delegates.glVertexStream1iATI((int)stream, (Int32)x);
        }

        public static 
        void glVertexStream1ivATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream1ivATI((int)stream, (Int32*)coords);
            }
        }

        public static 
        void glVertexStream1ivATI(int stream, Int32[] coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = coords)
                {
                    Delegates.glVertexStream1ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream1ivATI(int stream, ref Int32 coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = &coords)
                {
                    Delegates.glVertexStream1ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream1fATI(int stream, Single x)
        {
            Delegates.glVertexStream1fATI((int)stream, (Single)x);
        }

        public static 
        void glVertexStream1fvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream1fvATI((int)stream, (Single*)coords);
            }
        }

        public static 
        void glVertexStream1fvATI(int stream, Single[] coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = coords)
                {
                    Delegates.glVertexStream1fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream1fvATI(int stream, ref Single coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = &coords)
                {
                    Delegates.glVertexStream1fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream1dATI(int stream, Double x)
        {
            Delegates.glVertexStream1dATI((int)stream, (Double)x);
        }

        public static 
        void glVertexStream1dvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream1dvATI((int)stream, (Double*)coords);
            }
        }

        public static 
        void glVertexStream1dvATI(int stream, Double[] coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = coords)
                {
                    Delegates.glVertexStream1dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream1dvATI(int stream, ref Double coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = &coords)
                {
                    Delegates.glVertexStream1dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream2sATI(int stream, Int16 x, Int16 y)
        {
            Delegates.glVertexStream2sATI((int)stream, (Int16)x, (Int16)y);
        }

        public static 
        void glVertexStream2svATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream2svATI((int)stream, (Int16*)coords);
            }
        }

        public static 
        void glVertexStream2svATI(int stream, Int16[] coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = coords)
                {
                    Delegates.glVertexStream2svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream2svATI(int stream, ref Int16 coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = &coords)
                {
                    Delegates.glVertexStream2svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream2iATI(int stream, Int32 x, Int32 y)
        {
            Delegates.glVertexStream2iATI((int)stream, (Int32)x, (Int32)y);
        }

        public static 
        void glVertexStream2ivATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream2ivATI((int)stream, (Int32*)coords);
            }
        }

        public static 
        void glVertexStream2ivATI(int stream, Int32[] coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = coords)
                {
                    Delegates.glVertexStream2ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream2ivATI(int stream, ref Int32 coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = &coords)
                {
                    Delegates.glVertexStream2ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream2fATI(int stream, Single x, Single y)
        {
            Delegates.glVertexStream2fATI((int)stream, (Single)x, (Single)y);
        }

        public static 
        void glVertexStream2fvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream2fvATI((int)stream, (Single*)coords);
            }
        }

        public static 
        void glVertexStream2fvATI(int stream, Single[] coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = coords)
                {
                    Delegates.glVertexStream2fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream2fvATI(int stream, ref Single coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = &coords)
                {
                    Delegates.glVertexStream2fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream2dATI(int stream, Double x, Double y)
        {
            Delegates.glVertexStream2dATI((int)stream, (Double)x, (Double)y);
        }

        public static 
        void glVertexStream2dvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream2dvATI((int)stream, (Double*)coords);
            }
        }

        public static 
        void glVertexStream2dvATI(int stream, Double[] coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = coords)
                {
                    Delegates.glVertexStream2dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream2dvATI(int stream, ref Double coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = &coords)
                {
                    Delegates.glVertexStream2dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream3sATI(int stream, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexStream3sATI((int)stream, (Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void glVertexStream3svATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream3svATI((int)stream, (Int16*)coords);
            }
        }

        public static 
        void glVertexStream3svATI(int stream, Int16[] coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = coords)
                {
                    Delegates.glVertexStream3svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream3svATI(int stream, ref Int16 coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = &coords)
                {
                    Delegates.glVertexStream3svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream3iATI(int stream, Int32 x, Int32 y, Int32 z)
        {
            Delegates.glVertexStream3iATI((int)stream, (Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void glVertexStream3ivATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream3ivATI((int)stream, (Int32*)coords);
            }
        }

        public static 
        void glVertexStream3ivATI(int stream, Int32[] coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = coords)
                {
                    Delegates.glVertexStream3ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream3ivATI(int stream, ref Int32 coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = &coords)
                {
                    Delegates.glVertexStream3ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream3fATI(int stream, Single x, Single y, Single z)
        {
            Delegates.glVertexStream3fATI((int)stream, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void glVertexStream3fvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream3fvATI((int)stream, (Single*)coords);
            }
        }

        public static 
        void glVertexStream3fvATI(int stream, Single[] coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = coords)
                {
                    Delegates.glVertexStream3fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream3fvATI(int stream, ref Single coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = &coords)
                {
                    Delegates.glVertexStream3fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream3dATI(int stream, Double x, Double y, Double z)
        {
            Delegates.glVertexStream3dATI((int)stream, (Double)x, (Double)y, (Double)z);
        }

        public static 
        void glVertexStream3dvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream3dvATI((int)stream, (Double*)coords);
            }
        }

        public static 
        void glVertexStream3dvATI(int stream, Double[] coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = coords)
                {
                    Delegates.glVertexStream3dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream3dvATI(int stream, ref Double coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = &coords)
                {
                    Delegates.glVertexStream3dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream4sATI(int stream, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexStream4sATI((int)stream, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void glVertexStream4svATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream4svATI((int)stream, (Int16*)coords);
            }
        }

        public static 
        void glVertexStream4svATI(int stream, Int16[] coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = coords)
                {
                    Delegates.glVertexStream4svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream4svATI(int stream, ref Int16 coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = &coords)
                {
                    Delegates.glVertexStream4svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream4iATI(int stream, Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glVertexStream4iATI((int)stream, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void glVertexStream4ivATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream4ivATI((int)stream, (Int32*)coords);
            }
        }

        public static 
        void glVertexStream4ivATI(int stream, Int32[] coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = coords)
                {
                    Delegates.glVertexStream4ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream4ivATI(int stream, ref Int32 coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = &coords)
                {
                    Delegates.glVertexStream4ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream4fATI(int stream, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexStream4fATI((int)stream, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void glVertexStream4fvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream4fvATI((int)stream, (Single*)coords);
            }
        }

        public static 
        void glVertexStream4fvATI(int stream, Single[] coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = coords)
                {
                    Delegates.glVertexStream4fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream4fvATI(int stream, ref Single coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = &coords)
                {
                    Delegates.glVertexStream4fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream4dATI(int stream, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexStream4dATI((int)stream, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void glVertexStream4dvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glVertexStream4dvATI((int)stream, (Double*)coords);
            }
        }

        public static 
        void glVertexStream4dvATI(int stream, Double[] coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = coords)
                {
                    Delegates.glVertexStream4dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glVertexStream4dvATI(int stream, ref Double coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = &coords)
                {
                    Delegates.glVertexStream4dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormalStream3bATI(int stream, SByte nx, SByte ny, SByte nz)
        {
            Delegates.glNormalStream3bATI((int)stream, (SByte)nx, (SByte)ny, (SByte)nz);
        }

        public static 
        void glNormalStream3bATI(int stream, Byte nx, Byte ny, Byte nz)
        {
            Delegates.glNormalStream3bATI((int)stream, (SByte)nx, (SByte)ny, (SByte)nz);
        }

        public static 
        void glNormalStream3bvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glNormalStream3bvATI((int)stream, (SByte*)coords);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormalStream3bvATI(int stream, SByte[] coords)
        {
            unsafe
            {
                fixed (SByte* coords_ptr = coords)
                {
                    Delegates.glNormalStream3bvATI((int)stream, (SByte*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3bvATI(int stream, Byte[] coords)
        {
            unsafe
            {
                fixed (Byte* coords_ptr = coords)
                {
                    Delegates.glNormalStream3bvATI((int)stream, (SByte*)coords_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glNormalStream3bvATI(int stream, ref SByte coords)
        {
            unsafe
            {
                fixed (SByte* coords_ptr = &coords)
                {
                    Delegates.glNormalStream3bvATI((int)stream, (SByte*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3bvATI(int stream, ref Byte coords)
        {
            unsafe
            {
                fixed (Byte* coords_ptr = &coords)
                {
                    Delegates.glNormalStream3bvATI((int)stream, (SByte*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3sATI(int stream, Int16 nx, Int16 ny, Int16 nz)
        {
            Delegates.glNormalStream3sATI((int)stream, (Int16)nx, (Int16)ny, (Int16)nz);
        }

        public static 
        void glNormalStream3svATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glNormalStream3svATI((int)stream, (Int16*)coords);
            }
        }

        public static 
        void glNormalStream3svATI(int stream, Int16[] coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = coords)
                {
                    Delegates.glNormalStream3svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3svATI(int stream, ref Int16 coords)
        {
            unsafe
            {
                fixed (Int16* coords_ptr = &coords)
                {
                    Delegates.glNormalStream3svATI((int)stream, (Int16*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3iATI(int stream, Int32 nx, Int32 ny, Int32 nz)
        {
            Delegates.glNormalStream3iATI((int)stream, (Int32)nx, (Int32)ny, (Int32)nz);
        }

        public static 
        void glNormalStream3ivATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glNormalStream3ivATI((int)stream, (Int32*)coords);
            }
        }

        public static 
        void glNormalStream3ivATI(int stream, Int32[] coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = coords)
                {
                    Delegates.glNormalStream3ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3ivATI(int stream, ref Int32 coords)
        {
            unsafe
            {
                fixed (Int32* coords_ptr = &coords)
                {
                    Delegates.glNormalStream3ivATI((int)stream, (Int32*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3fATI(int stream, Single nx, Single ny, Single nz)
        {
            Delegates.glNormalStream3fATI((int)stream, (Single)nx, (Single)ny, (Single)nz);
        }

        public static 
        void glNormalStream3fvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glNormalStream3fvATI((int)stream, (Single*)coords);
            }
        }

        public static 
        void glNormalStream3fvATI(int stream, Single[] coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = coords)
                {
                    Delegates.glNormalStream3fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3fvATI(int stream, ref Single coords)
        {
            unsafe
            {
                fixed (Single* coords_ptr = &coords)
                {
                    Delegates.glNormalStream3fvATI((int)stream, (Single*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3dATI(int stream, Double nx, Double ny, Double nz)
        {
            Delegates.glNormalStream3dATI((int)stream, (Double)nx, (Double)ny, (Double)nz);
        }

        public static 
        void glNormalStream3dvATI(int stream, IntPtr coords)
        {
            unsafe
            {
                Delegates.glNormalStream3dvATI((int)stream, (Double*)coords);
            }
        }

        public static 
        void glNormalStream3dvATI(int stream, Double[] coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = coords)
                {
                    Delegates.glNormalStream3dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glNormalStream3dvATI(int stream, ref Double coords)
        {
            unsafe
            {
                fixed (Double* coords_ptr = &coords)
                {
                    Delegates.glNormalStream3dvATI((int)stream, (Double*)coords_ptr);
                }
            }
        }

        public static 
        void glClientActiveVertexStreamATI(int stream)
        {
            Delegates.glClientActiveVertexStreamATI((int)stream);
        }

        public static 
        void glVertexBlendEnviATI(int pname, Int32 param)
        {
            Delegates.glVertexBlendEnviATI((int)pname, (Int32)param);
        }

        public static 
        void glVertexBlendEnvfATI(int pname, Single param)
        {
            Delegates.glVertexBlendEnvfATI((int)pname, (Single)param);
        }

        public static 
        void glElementPointerATI(int type, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glElementPointerATI((int)type, (IntPtr)pointer);
            }
        }

        public static 
        void glElementPointerATI(int type, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glElementPointerATI((int)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glDrawElementArrayATI(int mode, Int32 count)
        {
            Delegates.glDrawElementArrayATI((int)mode, (Int32)count);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDrawRangeElementArrayATI(int mode, UInt32 start, UInt32 end, Int32 count)
        {
            Delegates.glDrawRangeElementArrayATI((int)mode, (UInt32)start, (UInt32)end, (Int32)count);
        }

        public static 
        void glDrawRangeElementArrayATI(int mode, Int32 start, Int32 end, Int32 count)
        {
            Delegates.glDrawRangeElementArrayATI((int)mode, (UInt32)start, (UInt32)end, (Int32)count);
        }

        public static 
        void glDrawBuffersATI(Int32 n, IntPtr bufs)
        {
            unsafe
            {
                Delegates.glDrawBuffersATI((Int32)n, (int*)bufs);
            }
        }

        public static 
        void glDrawBuffersATI(Int32 n, int[] bufs)
        {
            unsafe
            {
                fixed (int* bufs_ptr = bufs)
                {
                    Delegates.glDrawBuffersATI((Int32)n, (int*)bufs_ptr);
                }
            }
        }

        public static 
        void glDrawBuffersATI(Int32 n, ref int bufs)
        {
            unsafe
            {
                fixed (int* bufs_ptr = &bufs)
                {
                    Delegates.glDrawBuffersATI((Int32)n, (int*)bufs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        IntPtr glMapObjectBufferATI(UInt32 buffer)
        {
            return Delegates.glMapObjectBufferATI((UInt32)buffer);
        }

        public static 
        IntPtr glMapObjectBufferATI(Int32 buffer)
        {
            return Delegates.glMapObjectBufferATI((UInt32)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void glUnmapObjectBufferATI(UInt32 buffer)
        {
            Delegates.glUnmapObjectBufferATI((UInt32)buffer);
        }

        public static 
        void glUnmapObjectBufferATI(Int32 buffer)
        {
            Delegates.glUnmapObjectBufferATI((UInt32)buffer);
        }

        public static 
        void glStencilOpSeparateATI(int face, int sfail, int dpfail, int dppass)
        {
            Delegates.glStencilOpSeparateATI((int)face, (int)sfail, (int)dpfail, (int)dppass);
        }

        [System.CLSCompliant(false)]
        public static 
        void glStencilFuncSeparateATI(int frontfunc, int backfunc, Int32 @ref, UInt32 mask)
        {
            Delegates.glStencilFuncSeparateATI((int)frontfunc, (int)backfunc, (Int32)@ref, (UInt32)mask);
        }

        public static 
        void glStencilFuncSeparateATI(int frontfunc, int backfunc, Int32 @ref, Int32 mask)
        {
            Delegates.glStencilFuncSeparateATI((int)frontfunc, (int)backfunc, (Int32)@ref, (UInt32)mask);
        }

        [System.CLSCompliant(false)]
        public static 
        void glVertexAttribArrayObjectATI(UInt32 index, Int32 size, int type, Int32 normalized, Int32 stride, UInt32 buffer, UInt32 offset)
        {
            Delegates.glVertexAttribArrayObjectATI((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (UInt32)buffer, (UInt32)offset);
        }

        public static 
        void glVertexAttribArrayObjectATI(Int32 index, Int32 size, int type, Int32 normalized, Int32 stride, Int32 buffer, Int32 offset)
        {
            Delegates.glVertexAttribArrayObjectATI((UInt32)index, (Int32)size, (int)type, (Int32)normalized, (Int32)stride, (UInt32)buffer, (UInt32)offset);
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribArrayObjectfvATI(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (int)pname, (Single*)@params);
            }
        }

        public static 
        void glGetVertexAttribArrayObjectfvATI(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (int)pname, (Single*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribArrayObjectfvATI(UInt32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribArrayObjectfvATI(Int32 index, int pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (int)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribArrayObjectfvATI(UInt32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribArrayObjectfvATI(Int32 index, int pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (int)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribArrayObjectivATI(UInt32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        public static 
        void glGetVertexAttribArrayObjectivATI(Int32 index, int pname, [Out] IntPtr @params)
        {
            unsafe
            {
                Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (int)pname, (Int32*)@params);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribArrayObjectivATI(UInt32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void glGetVertexAttribArrayObjectivATI(Int32 index, int pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (int)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGetVertexAttribArrayObjectivATI(UInt32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glGetVertexAttribArrayObjectivATI(Int32 index, int pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (int)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void glElementPointerAPPLE(int type, IntPtr pointer)
        {
            unsafe
            {
                Delegates.glElementPointerAPPLE((int)type, (IntPtr)pointer);
            }
        }

        public static 
        void glElementPointerAPPLE(int type, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glElementPointerAPPLE((int)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glDrawElementArrayAPPLE(int mode, Int32 first, Int32 count)
        {
            Delegates.glDrawElementArrayAPPLE((int)mode, (Int32)first, (Int32)count);
        }

        [System.CLSCompliant(false)]
        public static 
        void glDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, Int32 first, Int32 count)
        {
            Delegates.glDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32)first, (Int32)count);
        }

        public static 
        void glDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, Int32 first, Int32 count)
        {
            Delegates.glDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32)first, (Int32)count);
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, IntPtr first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first, (Int32*)count, (Int32)primcount);
            }
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, IntPtr first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, IntPtr first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, Int32[] first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                {
                    Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, Int32[] first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, Int32[] first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, ref Int32 first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                {
                    Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, ref Int32 first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawElementArrayAPPLE(int mode, ref Int32 first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawElementArrayAPPLE((int)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, IntPtr first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count, (Int32)primcount);
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, IntPtr first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count, (Int32)primcount);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, IntPtr first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, IntPtr first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, IntPtr first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, IntPtr first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, Int32[] first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, Int32[] first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, Int32[] first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, Int32[] first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, Int32[] first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, Int32[] first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, ref Int32 first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, ref Int32 first, IntPtr count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, ref Int32 first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, ref Int32 first, Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, UInt32 start, UInt32 end, ref Int32 first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glMultiDrawRangeElementArrayAPPLE(int mode, Int32 start, Int32 end, ref Int32 first, ref Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawRangeElementArrayAPPLE((int)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void glGenFencesAPPLE(Int32 n, [Out] IntPtr fences)
        {
            unsafe
            {
                Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenFencesAPPLE(Int32 n, [Out] UInt32[] fences)
        {
            unsafe
            {
                fixed (UInt32* fences_ptr = fences)
                {
                    Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        public static 
        void glGenFencesAPPLE(Int32 n, [Out] Int32[] fences)
        {
            unsafe
            {
                fixed (Int32* fences_ptr = fences)
                {
                    Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenFencesAPPLE(Int32 n, [Out] out UInt32 fences)
        {
            unsafe
            {
                fixed (UInt32* fences_ptr = &fences)
                {
                    Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                    fences = *fences_ptr;
                }
            }
        }

        public static 
        void glGenFencesAPPLE(Int32 n, [Out] out Int32 fences)
        {
            unsafe
            {
                fixed (Int32* fences_ptr = &fences)
                {
                    Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                    fences = *fences_ptr;
                }
            }
        }

        public static 
        void glDeleteFencesAPPLE(Int32 n, IntPtr fences)
        {
            unsafe
            {
                Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteFencesAPPLE(Int32 n, UInt32[] fences)
        {
            unsafe
            {
                fixed (UInt32* fences_ptr = fences)
                {
                    Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        public static 
        void glDeleteFencesAPPLE(Int32 n, Int32[] fences)
        {
            unsafe
            {
                fixed (Int32* fences_ptr = fences)
                {
                    Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteFencesAPPLE(Int32 n, ref UInt32 fences)
        {
            unsafe
            {
                fixed (UInt32* fences_ptr = &fences)
                {
                    Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        public static 
        void glDeleteFencesAPPLE(Int32 n, ref Int32 fences)
        {
            unsafe
            {
                fixed (Int32* fences_ptr = &fences)
                {
                    Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glSetFenceAPPLE(UInt32 fence)
        {
            Delegates.glSetFenceAPPLE((UInt32)fence);
        }

        public static 
        void glSetFenceAPPLE(Int32 fence)
        {
            Delegates.glSetFenceAPPLE((UInt32)fence);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsFenceAPPLE(UInt32 fence)
        {
            return Delegates.glIsFenceAPPLE((UInt32)fence);
        }

        public static 
        Int32 glIsFenceAPPLE(Int32 fence)
        {
            return Delegates.glIsFenceAPPLE((UInt32)fence);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glTestFenceAPPLE(UInt32 fence)
        {
            return Delegates.glTestFenceAPPLE((UInt32)fence);
        }

        public static 
        Int32 glTestFenceAPPLE(Int32 fence)
        {
            return Delegates.glTestFenceAPPLE((UInt32)fence);
        }

        [System.CLSCompliant(false)]
        public static 
        void glFinishFenceAPPLE(UInt32 fence)
        {
            Delegates.glFinishFenceAPPLE((UInt32)fence);
        }

        public static 
        void glFinishFenceAPPLE(Int32 fence)
        {
            Delegates.glFinishFenceAPPLE((UInt32)fence);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glTestObjectAPPLE(int @object, UInt32 name)
        {
            return Delegates.glTestObjectAPPLE((int)@object, (UInt32)name);
        }

        public static 
        Int32 glTestObjectAPPLE(int @object, Int32 name)
        {
            return Delegates.glTestObjectAPPLE((int)@object, (UInt32)name);
        }

        public static 
        void glFinishObjectAPPLE(int @object, Int32 name)
        {
            Delegates.glFinishObjectAPPLE((int)@object, (Int32)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void glBindVertexArrayAPPLE(UInt32 array)
        {
            Delegates.glBindVertexArrayAPPLE((UInt32)array);
        }

        public static 
        void glBindVertexArrayAPPLE(Int32 array)
        {
            Delegates.glBindVertexArrayAPPLE((UInt32)array);
        }

        public static 
        void glDeleteVertexArraysAPPLE(Int32 n, IntPtr arrays)
        {
            unsafe
            {
                Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteVertexArraysAPPLE(Int32 n, UInt32[] arrays)
        {
            unsafe
            {
                fixed (UInt32* arrays_ptr = arrays)
                {
                    Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                }
            }
        }

        public static 
        void glDeleteVertexArraysAPPLE(Int32 n, Int32[] arrays)
        {
            unsafe
            {
                fixed (Int32* arrays_ptr = arrays)
                {
                    Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glDeleteVertexArraysAPPLE(Int32 n, ref UInt32 arrays)
        {
            unsafe
            {
                fixed (UInt32* arrays_ptr = &arrays)
                {
                    Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                }
            }
        }

        public static 
        void glDeleteVertexArraysAPPLE(Int32 n, ref Int32 arrays)
        {
            unsafe
            {
                fixed (Int32* arrays_ptr = &arrays)
                {
                    Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                }
            }
        }

        public static 
        void glGenVertexArraysAPPLE(Int32 n, [Out] IntPtr arrays)
        {
            unsafe
            {
                Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays);
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenVertexArraysAPPLE(Int32 n, [Out] UInt32[] arrays)
        {
            unsafe
            {
                fixed (UInt32* arrays_ptr = arrays)
                {
                    Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                }
            }
        }

        public static 
        void glGenVertexArraysAPPLE(Int32 n, [Out] Int32[] arrays)
        {
            unsafe
            {
                fixed (Int32* arrays_ptr = arrays)
                {
                    Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void glGenVertexArraysAPPLE(Int32 n, [Out] out UInt32 arrays)
        {
            unsafe
            {
                fixed (UInt32* arrays_ptr = &arrays)
                {
                    Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                    arrays = *arrays_ptr;
                }
            }
        }

        public static 
        void glGenVertexArraysAPPLE(Int32 n, [Out] out Int32 arrays)
        {
            unsafe
            {
                fixed (Int32* arrays_ptr = &arrays)
                {
                    Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                    arrays = *arrays_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 glIsVertexArrayAPPLE(UInt32 array)
        {
            return Delegates.glIsVertexArrayAPPLE((UInt32)array);
        }

        public static 
        Int32 glIsVertexArrayAPPLE(Int32 array)
        {
            return Delegates.glIsVertexArrayAPPLE((UInt32)array);
        }

        public static 
        void glVertexArrayRangeAPPLE(Int32 length, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glVertexArrayRangeAPPLE((Int32)length, (IntPtr)pointer);
            }
        }

        public static 
        void glVertexArrayRangeAPPLE(Int32 length, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexArrayRangeAPPLE((Int32)length, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glFlushVertexArrayRangeAPPLE(Int32 length, [Out] IntPtr pointer)
        {
            unsafe
            {
                Delegates.glFlushVertexArrayRangeAPPLE((Int32)length, (IntPtr)pointer);
            }
        }

        public static 
        void glFlushVertexArrayRangeAPPLE(Int32 length, [In, Out] object pointer)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glFlushVertexArrayRangeAPPLE((Int32)length, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }
        }

        public static 
        void glVertexArrayParameteriAPPLE(int pname, Int32 param)
        {
            Delegates.glVertexArrayParameteriAPPLE((int)pname, (Int32)param);
        }

        public static 
        void glBufferParameteriAPPLE(int target, int pname, Int32 param)
        {
            Delegates.glBufferParameteriAPPLE((int)target, (int)pname, (Int32)param);
        }

        public static 
        void glFlushMappedBufferRangeAPPLE(int target, IntPtr offset, IntPtr size)
        {
            Delegates.glFlushMappedBufferRangeAPPLE((int)target, (IntPtr)offset, (IntPtr)size);
        }

        public static 
        void glStringMarkerGREMEDY(Int32 len, IntPtr @string)
        {
            unsafe
            {
                Delegates.glStringMarkerGREMEDY((Int32)len, (IntPtr)@string);
            }
        }

        public static 
        void glStringMarkerGREMEDY(Int32 len, [In, Out] object @string)
        {
            unsafe
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glStringMarkerGREMEDY((Int32)len, (IntPtr)@string_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @string_ptr.Free();
                }
            }
        }

    }
}
